script-engine-lib 0.4.3 → 1.0.0-rc1

package/dist/simulator/event-test-simulator.js

@@ -1,373 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventTestSimulator = exports.StoryEngineSimulatorFunctions = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const action_before_testing_1 = require("../decorators/action-before-testing");
-const interfaces_1 = require("../interfaces");
-const structured_text_1 = require("../structured-text");
-const event_branches_map_1 = require("./helpers/event-branches-map");
-const execution_history_1 = require("./helpers/execution-history");
-class StoryEngineSimulatorFunctions {
-}
-exports.StoryEngineSimulatorFunctions = StoryEngineSimulatorFunctions;
-const MAX_CALL_STACK_DEPTH = 100;
-class EventTestSimulator {
-    constructor(eventDefinitions, options = { preventTypeChanges: true, richTextTags: undefined }) {
-        this.eventDefinitions = eventDefinitions;
-        this.options = options;
-        this.visitedBranchStates = new Map();
-        this.eventBranchesMap = new event_branches_map_1.EventBranchesMap(this.eventDefinitions);
-        if (this.options.preventTypeChanges) {
-            this.globalNameSpace = new Map();
-        }
-    }
-    /**
-     * @throws SimulationError, ActionsBeforeTestingError, BranchingBeforeTestingError
-     */
-    simulateEvent(eventDefinition, jsEngine, actionsBeforeTesting) {
-        if (this.options.preventTypeChanges) {
-            jsEngine.globalNameSpace = this.globalNameSpace;
-        }
-        let initialContext = {
-            executionHistory: new execution_history_1.ExecutionHistory(),
-            stack: new helpers_lib_1.Stack(),
-            jsEngine,
-            depth: 0,
-            lastExecutedAction: undefined
-        };
-        let allPossibleStates = [initialContext];
-        this.processActionsBeforeTesting(actionsBeforeTesting, allPossibleStates);
-        this.visitedBranchStates.clear();
-        this.executeEvent(eventDefinition, allPossibleStates);
-        this.visitedBranchStates.clear();
-    }
-    getUnvisitedBranchLocations() {
-        return this.eventBranchesMap.getUnvisitedBranchLocations();
-    }
-    processActionsBeforeTesting(actionsBeforeTesting, allPossibleStates) {
-        actionsBeforeTesting.forEach((action, index) => {
-            switch (action.type) {
-                case 'command':
-                    this.executeActionBeforeTesting(action, allPossibleStates, index);
-                    break;
-                case 'runEvent':
-                    this.branchOutFromEvent(action, allPossibleStates, index);
-                    break;
-                default:
-                    throw new Error(`Unknown action before testing type: ${action.type}`);
-            }
-        });
-    }
-    executeActionBeforeTesting(action, allPossibleStates, index) {
-        try {
-            allPossibleStates.forEach(state => {
-                Reflect.defineMetadata(action_before_testing_1.ActionBeforeTestingFlag, true, state.jsEngine.functions);
-                state.jsEngine.execute(action.value);
-            });
-        }
-        catch (e) {
-            let errorMessage = this.prepareErrorMessage(`${e}`, allPossibleStates[0].executionHistory);
-            throw new interfaces_1.ActionsBeforeTestingError(errorMessage, index);
-        }
-    }
-    branchOutFromEvent(action, allPossibleStates, index) {
-        let allPossibleEndings = [];
-        let targetEvent = this.eventBranchesMap.getEvent(action.value);
-        if (!targetEvent) {
-            throw new Error(`Target event is not found: ${action.value}`);
-        }
-        try {
-            this.visitedBranchStates.clear();
-            allPossibleStates.forEach(state => {
-                state.executionHistory.addEntry(`Branching out from event: ${action.value}`);
-                state.depth = 0;
-                Reflect.defineMetadata(action_before_testing_1.ActionBeforeTestingFlag, false, state.jsEngine.functions);
-                let executionResult = this.executeBranch(targetEvent, state, false);
-                if (!executionResult.exitFound) {
-                    let errorMessage = this.prepareErrorMessage(`All possible paths are creating infinite loops, no exit found while executing: ${action.value}`, state.executionHistory);
-                    throw new interfaces_1.SimulationError(errorMessage, this.eventBranchesMap.getRootBranchLocation(targetEvent));
-                }
-                executionResult.allEndings.forEach(ending => {
-                    allPossibleEndings.push(ending);
-                });
-            });
-            let uniqueEndings = this.removeDuplicateEndings(allPossibleEndings);
-            allPossibleStates.length = 0;
-            allPossibleStates.push(...uniqueEndings);
-            allPossibleStates.forEach(ending => {
-                ending.executionHistory
-                    .addEntry(`${uniqueEndings.length} unique ending${uniqueEndings.length > 1 ? 's' : ''} generated.`)
-                    .addEntry('');
-                if (!ending.lastExecutedAction) {
-                    throw new Error('Event execution is ended without executing any command!');
-                }
-                else {
-                    try {
-                        ending.jsEngine.functions.onEventBranchingEnd();
-                    }
-                    catch (e) {
-                        let path = this.eventBranchesMap.getActionLocation(ending.lastExecutedAction);
-                        let errorMessage = this.prepareErrorMessage(`${e}`, ending.executionHistory);
-                        throw new interfaces_1.SimulationError(errorMessage, path);
-                    }
-                }
-            });
-        }
-        catch (e) {
-            if (e instanceof interfaces_1.SimulationError) {
-                throw new interfaces_1.BranchingBeforeTestingError(`${e.message}`, index, e.location);
-            }
-            else {
-                throw e;
-            }
-        }
-    }
-    executeEvent(eventDefinition, allPossibleStates) {
-        allPossibleStates.forEach(state => {
-            state.executionHistory.addEntry(`Running event: ${eventDefinition.id}`);
-            state.depth = 0;
-            Reflect.defineMetadata(action_before_testing_1.ActionBeforeTestingFlag, false, state.jsEngine.functions);
-            let executionResult = this.executeBranch(eventDefinition, state, true);
-            if (!executionResult.exitFound) {
-                let errorMessage = this.prepareErrorMessage(`All possible paths are creating infinite loops, no exit found while executing: ${eventDefinition.id}`, state.executionHistory);
-                throw new interfaces_1.SimulationError(errorMessage, this.eventBranchesMap.getRootBranchLocation(eventDefinition));
-            }
-            executionResult.allEndings.forEach(ending => {
-                if (!ending.lastExecutedAction) {
-                    throw new Error('Event execution is ended without executing any command!');
-                }
-                else {
-                    try {
-                        ending.jsEngine.functions.onEnd();
-                    }
-                    catch (e) {
-                        let path = this.eventBranchesMap.getActionLocation(ending.lastExecutedAction);
-                        let errorMessage = this.prepareErrorMessage(`${e}`, ending.executionHistory);
-                        throw new interfaces_1.SimulationError(errorMessage, path);
-                    }
-                }
-            });
-        });
-    }
-    executeBranch(branch, context, registerVisitedBranches) {
-        if (!this.isBranchVisitedAndRegister(branch, context)) {
-            return {
-                allEndings: [],
-                exitFound: false
-            };
-        }
-        let allPossibleEndings = [];
-        let exitFound = true;
-        if (registerVisitedBranches) {
-            this.eventBranchesMap.setVisited(branch);
-        }
-        context.depth++;
-        if (context.depth > MAX_CALL_STACK_DEPTH) {
-            let errorMessage = this.prepareErrorMessage(`Maximum depth "${MAX_CALL_STACK_DEPTH}" is reached. Try to reduce the event branching tree or check infinite loops with trivial state changes.`, context.executionHistory);
-            throw new interfaces_1.SimulationError(errorMessage, this.eventBranchesMap.getRootBranchLocation(branch));
-        }
-        context.stack.add(...branch.actions);
-        while (!context.stack.isEmpty) {
-            let action = context.stack.pop();
-            let executionResult = this.executeAction(action, context, registerVisitedBranches);
-            if (context.stack.isEmpty) {
-                allPossibleEndings.push(...executionResult.allEndings);
-                exitFound = executionResult.exitFound && exitFound;
-            }
-        }
-        allPossibleEndings = allPossibleEndings.length > 0 ? this.removeDuplicateEndings(allPossibleEndings) : [];
-        return {
-            allEndings: allPossibleEndings,
-            exitFound
-        };
-    }
-    executeAction(action, context, registerVisitedBranches) {
-        context.lastExecutedAction = action;
-        switch (action.type) {
-            case 'command':
-                return this.executeActionCommand(action, context);
-            case 'dialog':
-                return this.executeDialogCommand(action, context);
-            case 'jumpToEvent':
-                return this.executeActionJumpToEvent(action, context, registerVisitedBranches);
-            case 'branchByCondition':
-                return this.executeActionBranchByCondition(action, context, registerVisitedBranches);
-            case 'branchByChance':
-                return this.executeActionBranchByChance(action, context, registerVisitedBranches);
-            case 'branchByPlayerChoice':
-                return this.executeActionBranchByPlayerChoice(action, context, registerVisitedBranches);
-            default:
-                throw new Error(`Unknown action type: ${action.type}`);
-        }
-    }
-    executeActionCommand(action, context) {
-        try {
-            context.jsEngine.execute(action.value);
-        }
-        catch (e) {
-            let path = this.eventBranchesMap.getActionLocation(action);
-            let errorMessage = this.prepareErrorMessage(`${e}`, context.executionHistory);
-            throw new interfaces_1.SimulationError(errorMessage, path);
-        }
-        return {
-            allEndings: [context],
-            exitFound: true
-        };
-    }
-    executeDialogCommand(action, context) {
-        let dialogItem = action.value;
-        let text;
-        try {
-            text = context.jsEngine.string(dialogItem.text);
-            this.options.richTextTags && structured_text_1.RichTextValidator.validate(text, this.options.richTextTags);
-            context.jsEngine.functions.onDialog(text, dialogItem.speaker);
-        }
-        catch (e) {
-            let path = this.eventBranchesMap.getActionLocation(action);
-            let errorMessage = this.prepareErrorMessage(`${e}`, context.executionHistory);
-            throw new interfaces_1.SimulationError(errorMessage, path);
-        }
-        return {
-            allEndings: [context],
-            exitFound: true
-        };
-    }
-    executeActionJumpToEvent(action, context, registerVisitedBranches) {
-        let targetEvent = this.eventBranchesMap.getEvent(action.value);
-        context.executionHistory.addEntry(`Jumping to event: ${action.value}`);
-        return this.executeBranch(targetEvent, context, registerVisitedBranches);
-    }
-    executeActionBranchByCondition(action, context, registerVisitedBranches) {
-        let subBranches = action.value;
-        let validBranch = subBranches.find(subBranch => this.checkBranchCondition(subBranch, context));
-        if (!validBranch) {
-            let path = this.eventBranchesMap.getActionLocation(action);
-            let errorMessage = this.prepareErrorMessage(`No option is fulfilled the condition during branching.`, context.executionHistory);
-            throw new interfaces_1.SimulationError(errorMessage, path);
-        }
-        context.executionHistory.addEntry(`Branching by condition: ${validBranch.condition ? validBranch.condition : 'default'}`);
-        return this.executeBranch(validBranch, context, registerVisitedBranches);
-    }
-    executeActionBranchByChance(action, context, registerVisitedBranches) {
-        let subBranches = action.value;
-        let validItems = subBranches
-            .map((subBranch, index) => ({ index, subBranch }))
-            .filter(item => this.checkBranchCondition(item.subBranch, context));
-        if (validItems.length === 0) {
-            let path = this.eventBranchesMap.getActionLocation(action);
-            let errorMessage = this.prepareErrorMessage(`No option is fulfilled the condition during branching.`, context.executionHistory);
-            throw new interfaces_1.SimulationError(errorMessage, path);
-        }
-        let allExecutionResults = validItems.map(item => {
-            try {
-                let weight = helpers_lib_1.Comparator.isString(item.subBranch.weight)
-                    ? context.jsEngine.number(item.subBranch.weight)
-                    : item.subBranch.weight;
-                if (!helpers_lib_1.Comparator.isNumber(weight) || weight < 0) {
-                    throw new Error(`Weight of branch ${item.index} is not a valid number: "${item.subBranch.weight}" -> ${weight}.`);
-                }
-            }
-            catch (e) {
-                let path = this.eventBranchesMap.getActionLocation(action);
-                let errorMessage = this.prepareErrorMessage(`${e}`, context.executionHistory);
-                throw new interfaces_1.SimulationError(errorMessage, path);
-            }
-            let newContext = this.duplicateContext(context);
-            newContext.executionHistory.addEntry(`Branching by chance: ${item.index}`);
-            return this.executeBranch(item.subBranch, newContext, registerVisitedBranches);
-        });
-        return {
-            allEndings: allExecutionResults.flatMap(result => result.allEndings),
-            exitFound: allExecutionResults.some(result => result.exitFound)
-        };
-    }
-    executeActionBranchByPlayerChoice(action, context, registerVisitedBranches) {
-        let subBranches = action.value;
-        let validBranches = subBranches.filter(subBranch => this.checkBranchCondition(subBranch, context));
-        if (validBranches.length === 0) {
-            let path = this.eventBranchesMap.getActionLocation(action);
-            let errorMessage = this.prepareErrorMessage(`No option is fulfilled the condition during branching.`, context.executionHistory);
-            throw new interfaces_1.SimulationError(errorMessage, path);
-        }
-        try {
-            context.jsEngine.functions.onPlayerChoice(validBranches.map(branch => context.jsEngine.string(branch.text)));
-        }
-        catch (e) {
-            let path = this.eventBranchesMap.getActionLocation(action);
-            let errorMessage = this.prepareErrorMessage(`${e}`, context.executionHistory);
-            throw new interfaces_1.SimulationError(errorMessage, path);
-        }
-        let allExecutionResults = validBranches.map(subBranch => {
-            let newContext = this.duplicateContext(context);
-            newContext.executionHistory.addEntry(`Player choice: ${subBranch.text}`);
-            return this.executeBranch(subBranch, newContext, registerVisitedBranches);
-        });
-        return {
-            allEndings: allExecutionResults.flatMap(result => result.allEndings),
-            exitFound: allExecutionResults.some(result => result.exitFound)
-        };
-    }
-    checkBranchCondition(branch, context) {
-        if (!branch.condition) {
-            return true;
-        }
-        else {
-            try {
-                return context.jsEngine.boolean(branch.condition);
-            }
-            catch (e) {
-                let path = this.eventBranchesMap.getBranchLocation(branch);
-                let errorMessage = this.prepareErrorMessage(`${e}`, context.executionHistory);
-                throw new interfaces_1.SimulationError(errorMessage, path);
-            }
-        }
-    }
-    removeDuplicateEndings(allPossibleEndings) {
-        let uniqueEndings = [];
-        let processedEndings = allPossibleEndings.map(ending => ({
-            ending: ending,
-            variablesString: JSON.stringify(ending.jsEngine.variables),
-            functionsString: JSON.stringify(ending.jsEngine.functions)
-        }));
-        processedEndings.forEach(data => {
-            let isUnique = uniqueEndings.every(uniqueEnding => data.functionsString !== uniqueEnding.functionsString || data.variablesString !== uniqueEnding.variablesString);
-            if (isUnique) {
-                uniqueEndings.push({
-                    ending: data.ending,
-                    variablesString: data.variablesString,
-                    functionsString: data.functionsString
-                });
-            }
-        });
-        return uniqueEndings.map(data => data.ending);
-    }
-    isBranchVisitedAndRegister(branch, context) {
-        let stateString = JSON.stringify(context.jsEngine.variables) + JSON.stringify(context.jsEngine.functions);
-        let branchStates = this.visitedBranchStates.get(branch);
-        if (!branchStates) {
-            branchStates = new Set();
-            this.visitedBranchStates.set(branch, branchStates);
-        }
-        if (branchStates.has(stateString)) {
-            return false;
-        }
-        else {
-            branchStates.add(stateString);
-            return true;
-        }
-    }
-    duplicateContext(context) {
-        return {
-            executionHistory: context.executionHistory.duplicate(),
-            stack: context.stack.duplicate(),
-            jsEngine: context.jsEngine.duplicate(),
-            depth: context.depth,
-            lastExecutedAction: context.lastExecutedAction
-        };
-    }
-    prepareErrorMessage(errorMessage, executionHistory) {
-        return `${errorMessage}\n\n----Execution history----\n${executionHistory.toString()}`;
-    }
-}
-exports.EventTestSimulator = EventTestSimulator;
-//# sourceMappingURL=event-test-simulator.js.map

package/dist/simulator/event-test-simulator.test.d.ts

@@ -1 +0,0 @@
-export {};