@turnipxenon/pineapple 2.2.1 → 2.3.1

package/dist/components/dialog_manager/DialogManager.d.ts

@@ -0,0 +1,77 @@
+/**
+ * DialogManager is the object we want to interact with in Svelte
+ */
+/// <reference types="svelte" />
+import type { DialogDetail } from "../../types/pineapple_fiber/DialogDetail";
+import { DialogState } from "../../types/pineapple_fiber/DialogState";
+import { DialogProcessor } from "./DialogProcessor";
+export type OnSetDialogChoiceCallback = (newMessage: DialogDetail) => void;
+export declare class DialogManager {
+    dialogMessageMap: Map<string, DialogDetail>;
+    dialogMessageList: DialogDetail[];
+    fullCurrentMessage: string;
+    currentMessageMeta: DialogDetail;
+    currentMessage: import("svelte/store").Writable<string>;
+    currentIndex: number;
+    previousTimestamp: number;
+    isDoneTransition: boolean;
+    currentPortrait: import("svelte/store").Writable<unknown>;
+    portraitMap: Map<string, any>;
+    currentState: DialogState;
+    hidePercent: import("svelte/motion").Tweened<number>;
+    skipNextActiveTime: number;
+    dialogProcessor: DialogProcessor;
+    _setDialogChoiceQueue: DialogDetail[];
+    _setDialogChoiceMutex: boolean;
+    onSetDialogListeners: OnSetDialogChoiceCallback[];
+    constructor();
+    /**
+     * when users interact with the dialog, they can skip the transition like in a game
+     * note that there is a cool down to this, check out skipNextActiveTime
+     */
+    skipAnimation: () => void;
+    /**
+     * hides or shows the dialog UI
+     * @param shouldEnable
+     */
+    enableDialog: (shouldEnable: boolean) => void;
+    /**
+     * sets the possible dialog that might appear on the Dialog UI
+     * note that it overwrites the previous tree and does not append on it due to the possibility
+     * of node name conflicts
+     * @param newMessageList
+     */
+    setDialogTree: (newMessageList: DialogDetail[]) => void;
+    /**
+     * Remember to call this before SetDialogTree
+     * and unsubscribe during onDestroy
+     * @param callback
+     */
+    subscribeToSetDialogChoice: (callback: OnSetDialogChoiceCallback) => void;
+    /**
+     * Remember to call this during onDestroy
+     * @param callback
+     * todo: double check if this works???
+     */
+    unsubscribeToSetDialogChoice: (callback: OnSetDialogChoiceCallback) => void;
+    /**
+     * Sets the next dialog to show depending on which special choice a href link the user
+     * has interacted with
+     * @param newMessage
+     *
+     * you can listen to this!
+     */
+    setDialogChoice: (newMessage: DialogDetail | undefined) => void;
+    _setDialogChoice: () => void;
+    setDialogToDefault: () => void;
+    /**
+     * updates the information and detail frame by frame
+     * you can think of this like the main game loop
+     *
+     * @param timestamp
+     *
+     * todo: this might be too big we might want to refactor this method for better readability
+     * ISSUE #81 https://github.com/TurnipXenon/pineapple/issues/81
+     */
+    update: (timestamp: number) => void;
+}

package/dist/components/dialog_manager/DialogManager.js

@@ -0,0 +1,239 @@
+/**
+ * DialogManager is the object we want to interact with in Svelte
+ */
+import { writable } from "svelte/store";
+import { DialogState } from "../../types/pineapple_fiber/DialogState";
+import { tweened } from "svelte/motion";
+import { cubicOut } from "svelte/easing";
+import { PortraitType } from "../../types/pineapple_fiber/PortraitType";
+import AresHappy from "../../assets/characters/ares/ares_happy.webp";
+import AresBlushing from "../../assets/characters/ares/ares_blushing.webp";
+import AresDisappointed from "../../assets/characters/ares/ares_disappointed.webp";
+import AresLetsGo from "../../assets/characters/ares/ares_lets_go.webp";
+import AresMad from "../../assets/characters/ares/ares_mad.webp";
+import AresNeutral from "../../assets/characters/ares/ares_neutral.webp";
+import AresSlightlyMad from "../../assets/characters/ares/ares_slightly_mad.webp";
+import AresSurprised from "../../assets/characters/ares/ares_surprised.webp";
+import AresYay from "../../assets/characters/ares/ares_yay.webp";
+import { defaultDialogMessage, dialogVariableStore, enableDialogueOverlay, updateRate } from "./DialogManagerStore";
+import { DialogProcessor } from "./DialogProcessor";
+const shouldDebugYarn = false;
+export class DialogManager {
+    dialogMessageMap = new Map();
+    dialogMessageList = [];
+    fullCurrentMessage = defaultDialogMessage[0].textContent;
+    currentMessageMeta = defaultDialogMessage[0];
+    currentMessage = writable("");
+    currentIndex = 0;
+    previousTimestamp = 0;
+    isDoneTransition = false;
+    currentPortrait = writable();
+    portraitMap = new Map();
+    currentState = DialogState.Visible;
+    hidePercent = tweened(100, {
+        duration: 400,
+        easing: cubicOut
+    }); // 100 = 100%
+    skipNextActiveTime = 0;
+    dialogProcessor = new DialogProcessor();
+    // for queueing actions
+    _setDialogChoiceQueue = [];
+    _setDialogChoiceMutex = false;
+    onSetDialogListeners = [];
+    constructor() {
+        enableDialogueOverlay.subscribe((value) => {
+            // todo: investigate why we cant put setDialogDefault inside the then clause
+            // ISSUE #82 https://github.com/TurnipXenon/pineapple/issues/82
+            if (value) {
+                this.hidePercent.set(0);
+                this.setDialogToDefault();
+            }
+            else {
+                this.hidePercent.set(100);
+                this.setDialogTree([{ textContent: "" }]);
+            }
+        });
+    }
+    /**
+     * when users interact with the dialog, they can skip the transition like in a game
+     * note that there is a cool down to this, check out skipNextActiveTime
+     */
+    skipAnimation = () => {
+        if (this.previousTimestamp > this.skipNextActiveTime &&
+            this.currentState == DialogState.Visible &&
+            !this.isDoneTransition // crucial for dynamic links!
+        ) {
+            this.currentIndex = this.fullCurrentMessage.length - 1;
+            this.currentMessage.update(() => this.fullCurrentMessage.slice(0, this.currentIndex));
+        }
+    };
+    /**
+     * hides or shows the dialog UI
+     * @param shouldEnable
+     */
+    enableDialog = (shouldEnable) => {
+        enableDialogueOverlay.update(() => shouldEnable);
+    };
+    /**
+     * sets the possible dialog that might appear on the Dialog UI
+     * note that it overwrites the previous tree and does not append on it due to the possibility
+     * of node name conflicts
+     * @param newMessageList
+     */
+    setDialogTree = (newMessageList) => {
+        this.dialogMessageList = newMessageList;
+        this.dialogMessageMap.clear();
+        newMessageList.map((value) => {
+            if (value.dialogId) {
+                this.dialogMessageMap.set(value.dialogId, value);
+            }
+        });
+        // lazy load map
+        if (this.portraitMap.size == 0) {
+            this.portraitMap.set(PortraitType.AresHappy.toString(), AresHappy);
+            this.portraitMap.set(PortraitType.AresBlushing.toString(), AresBlushing);
+            this.portraitMap.set(PortraitType.AresDisappointed.toString(), AresDisappointed);
+            this.portraitMap.set(PortraitType.AresLetsGo.toString(), AresLetsGo);
+            this.portraitMap.set(PortraitType.AresMad.toString(), AresMad);
+            this.portraitMap.set(PortraitType.AresNeutral.toString(), AresNeutral);
+            this.portraitMap.set(PortraitType.AresSlightlyMad.toString(), AresSlightlyMad);
+            this.portraitMap.set(PortraitType.AresSurprised.toString(), AresSurprised);
+            this.portraitMap.set(PortraitType.AresYay.toString(), AresYay);
+        }
+        this.setDialogChoice(newMessageList[0]);
+    };
+    /**
+     * Remember to call this before SetDialogTree
+     * and unsubscribe during onDestroy
+     * @param callback
+     */
+    subscribeToSetDialogChoice = (callback) => {
+        this.onSetDialogListeners.push(callback);
+    };
+    /**
+     * Remember to call this during onDestroy
+     * @param callback
+     * todo: double check if this works???
+     */
+    unsubscribeToSetDialogChoice = (callback) => {
+        // from: https://stackoverflow.com/a/5767357/17836168
+        const index = this.onSetDialogListeners.indexOf(callback);
+        if (index > -1) {
+            // only splice array when item is found
+            this.onSetDialogListeners.splice(index, 1); // 2nd parameter means remove one item only
+        }
+    };
+    /**
+     * Sets the next dialog to show depending on which special choice a href link the user
+     * has interacted with
+     * @param newMessage
+     *
+     * you can listen to this!
+     */
+    setDialogChoice = (newMessage) => {
+        if (!newMessage || !newMessage.textContent) {
+            return;
+        }
+        this._setDialogChoiceQueue.push(newMessage);
+        if (!this._setDialogChoiceMutex) {
+            this._setDialogChoiceMutex = true; // not a true mutex but this will do
+            this._setDialogChoice();
+        }
+    };
+    _setDialogChoice = () => {
+        const newMessage = this._setDialogChoiceQueue.shift();
+        if (newMessage === undefined) {
+            this._setDialogChoiceMutex = false; // set it free!
+            this.onSetDialogListeners.forEach((listener) => {
+                listener(this.currentMessageMeta);
+            });
+            return;
+        }
+        this.currentMessageMeta = newMessage;
+        // set the portrait
+        let portraitValue = AresHappy;
+        if (this.currentMessageMeta.portraitType) {
+            portraitValue = this.portraitMap.get(this.currentMessageMeta.portraitType);
+        }
+        if (portraitValue) {
+            this.currentPortrait.update(() => portraitValue);
+        }
+        // process the dialogue here line-by-line
+        this.fullCurrentMessage = this.dialogProcessor.processDialog(this.currentMessageMeta);
+        this.currentMessage.update(() => "");
+        this.currentIndex = 0;
+        this.skipNextActiveTime = this.previousTimestamp + 1000; // guard
+        this.isDoneTransition = false; // must be after the guard
+        if (shouldDebugYarn) {
+            console.info(`Currently processing node: ${this.currentMessageMeta.dialogId}`);
+        }
+        // save that we visited AND processed the node
+        if (this.currentMessageMeta.dialogId) {
+            const key = `+${this.currentMessageMeta.dialogId}`;
+            const value = Number(dialogVariableStore.getItem(key));
+            if (isNaN(value)) {
+                dialogVariableStore.setItem(key, "1");
+            }
+            else {
+                dialogVariableStore.setItem(key, `${value + 1}`);
+            }
+        }
+        // reloop this to process all messages
+        this._setDialogChoice();
+    };
+    setDialogToDefault = () => {
+        this.setDialogTree(defaultDialogMessage);
+    };
+    /**
+     * updates the information and detail frame by frame
+     * you can think of this like the main game loop
+     *
+     * @param timestamp
+     *
+     * todo: this might be too big we might want to refactor this method for better readability
+     * ISSUE #81 https://github.com/TurnipXenon/pineapple/issues/81
+     */
+    update = (timestamp) => {
+        if (this.currentState == DialogState.Invisible || this.currentState == DialogState.Busy) {
+            window.requestAnimationFrame(this.update);
+            return;
+        }
+        // if visible
+        // text transition loop
+        if (!this.isDoneTransition && this.currentIndex > this.fullCurrentMessage.length) {
+            const elementList = document.getElementsByClassName("dialog-choice");
+            for (const el of elementList) {
+                el.addEventListener("click", (event) => {
+                    // todo: make more robust; for now we're assuming first class is our choice
+                    const choice = el.classList[0].split("-")[1];
+                    this.setDialogChoice(this.dialogMessageMap.get(choice));
+                });
+            }
+            this.isDoneTransition = true;
+        }
+        // guard: skip if done or if not yet time to update
+        if (this.currentIndex > this.fullCurrentMessage.length ||
+            this.previousTimestamp + updateRate > timestamp) {
+            window.requestAnimationFrame(this.update);
+            return;
+        }
+        this.previousTimestamp = timestamp;
+        // check if valid text
+        // there is an assumption that previous character is valid
+        // let validCharacterIndex = this.currentLength - 1;
+        // validCharacterIndex++;
+        // the code above is just to show you how it looks like but let's assume
+        // that currentLength = validCharacter + 1
+        while (this.fullCurrentMessage[this.currentIndex] == "<" &&
+            this.currentIndex + 1 < this.fullCurrentMessage.length) {
+            // find valid character, trap with closing
+            this.currentIndex = this.fullCurrentMessage.indexOf(">", this.currentIndex) + 1;
+            // normalize
+            this.currentIndex = Math.min(this.currentIndex, this.fullCurrentMessage.length - 1);
+        }
+        this.currentMessage.update(() => this.fullCurrentMessage.slice(0, this.currentIndex));
+        // increment
+        ++this.currentIndex;
+        window.requestAnimationFrame(this.update);
+    };
+}

package/dist/components/dialog_manager/DialogManagerStore.d.ts

@@ -0,0 +1,41 @@
+/**
+ * DialogManagerStore is for variables that will be used as a Svelte store
+ * or is saved in local storage
+ */
+/// <reference types="svelte" />
+import type { DialogMapStore } from "../../types/pineapple_fiber/DialogVariableStore";
+import type { DialogDetail } from "../../types/pineapple_fiber/DialogDetail";
+import { DialogManager } from "./DialogManager";
+/**
+ * Enables the dialogue overlay
+ *
+ * @example
+ * When updating to false, remember to restore the value to true, our default value, onDestroy.
+ * Avoid async to prevent weird flashes of updates!
+ * ```
+ * import {enableDialogueOverlay} from "../../store.ts";
+ * enableDialogueOverlay.update(() => false);
+ *
+ * onDestroy(() => {
+ *     enableDialogueOverlay.update(() =>  true);
+ * });
+ * ```
+ */
+export declare const enableDialogueOverlay: import("svelte/store").Writable<boolean>;
+export declare const dialogVariableStore: DialogMapStore;
+export declare const updateRate: number;
+export declare const defaultDialogMessage: DialogDetail[];
+/**
+ * strictly must be declared last! or you might receive a weird error that looks like:
+ *
+ * 2:04:21 AM [vite] Error when evaluating SSR module /src/lib/components/dialog_manager/DialogManagerStore.ts:
+ * |- TypeError: Cannot read properties of undefined (reading '0')
+ *     at <instance_members_initializer> (/src/lib/components/dialog_manager/DialogManager.ts:38:67)
+ *     at new DialogManager (/src/lib/components/dialog_manager/DialogManager.ts:53:14)
+ *     at eval (/src/lib/components/dialog_manager/DialogManagerStore.ts:15:23)
+ *     at async instantiateModule (file:///C:/Users/Pumpkin/Projects/Web/pineapple/node_modules/vite/dist/node/chunks/dep-934dbc7c.js:54360:9)
+ *
+ * what this means is that one member of dialogManager cannot be initialized. in our case, it was the
+ * defaultDialogMessage not yet being initialized
+ */
+export declare const dialogManager: DialogManager;

package/dist/components/dialog_manager/DialogManagerStore.js

@@ -0,0 +1,45 @@
+/**
+ * DialogManagerStore is for variables that will be used as a Svelte store
+ * or is saved in local storage
+ */
+import { createNewMapStore } from "../../types/pineapple_fiber/DialogVariableStore";
+import { writable } from "svelte/store";
+import { DialogManager } from "./DialogManager";
+/**
+ * Enables the dialogue overlay
+ *
+ * @example
+ * When updating to false, remember to restore the value to true, our default value, onDestroy.
+ * Avoid async to prevent weird flashes of updates!
+ * ```
+ * import {enableDialogueOverlay} from "../../store.ts";
+ * enableDialogueOverlay.update(() => false);
+ *
+ * onDestroy(() => {
+ *     enableDialogueOverlay.update(() =>  true);
+ * });
+ * ```
+ */
+export const enableDialogueOverlay = writable(true);
+export const dialogVariableStore = createNewMapStore();
+export const updateRate = 40 / 1000; // *at least* 40ms per letter
+// todo: if we go through doing yarn to typescript, move this!
+export const defaultDialogMessage = [
+    {
+        textContent: `<p>Have you drank water? Or perhaps, you've checked out <a target="_blank" class="external-link" href="http://crouton.net">one of the best webpages</a> out there?`
+    }
+];
+/**
+ * strictly must be declared last! or you might receive a weird error that looks like:
+ *
+ * 2:04:21 AM [vite] Error when evaluating SSR module /src/lib/components/dialog_manager/DialogManagerStore.ts:
+ * |- TypeError: Cannot read properties of undefined (reading '0')
+ *     at <instance_members_initializer> (/src/lib/components/dialog_manager/DialogManager.ts:38:67)
+ *     at new DialogManager (/src/lib/components/dialog_manager/DialogManager.ts:53:14)
+ *     at eval (/src/lib/components/dialog_manager/DialogManagerStore.ts:15:23)
+ *     at async instantiateModule (file:///C:/Users/Pumpkin/Projects/Web/pineapple/node_modules/vite/dist/node/chunks/dep-934dbc7c.js:54360:9)
+ *
+ * what this means is that one member of dialogManager cannot be initialized. in our case, it was the
+ * defaultDialogMessage not yet being initialized
+ */
+export const dialogManager = new DialogManager();

package/dist/components/dialog_manager/DialogProcessor.d.ts

@@ -0,0 +1,13 @@
+import type { DialogDetail } from "../../types/pineapple_fiber/DialogDetail";
+import { LineSelectorNode } from "./behavior_tree/line_core/LineSelectorNode";
+/**
+ * DialogProcessor processes dialogs
+ */
+export declare class DialogProcessor {
+    processingTree: LineSelectorNode;
+    /**
+     * process the dialog line by line and return a presentable string
+     * @param dialogDetail
+     */
+    processDialog: (dialogDetail: DialogDetail) => string;
+}

package/dist/components/dialog_manager/DialogProcessor.js

@@ -0,0 +1,62 @@
+import { BehaviorState } from "./behavior_tree/line_processors/BehaviorState";
+import { IfNode } from "./behavior_tree/line_processors/IfNode";
+import { EndIfNode } from "./behavior_tree/line_processors/EndIfNode";
+import { ElseNode } from "./behavior_tree/line_processors/ElseNode";
+import { ElseIfNode } from "./behavior_tree/line_processors/ElseIfNode";
+import { SetVariableNode } from "./behavior_tree/line_processors/SetVariableNode";
+import { IgnoreGuardNode } from "./behavior_tree/line_processors/IgnoreGuardNode";
+import { NormalLineProcessorNode } from "./behavior_tree/line_processors/NormalLineProcessorNode";
+import { LineSelectorNode } from "./behavior_tree/line_core/LineSelectorNode";
+import { browser } from "$app/environment";
+import { LineCommentNode } from "./behavior_tree/line_processors/LineCommentNode";
+import { DeclareCommand } from "./behavior_tree/line_processors/commands/DeclareCommand";
+import { JumpCommand } from "./behavior_tree/line_processors/commands/JumpCommand";
+import { IgnoreJumpNode } from "./behavior_tree/line_processors/IgnoreJumpNode";
+import { UnvisitCommand } from "./behavior_tree/line_processors/commands/UnvisitCommand";
+/**
+ * DialogProcessor processes dialogs
+ */
+export class DialogProcessor {
+    processingTree = new LineSelectorNode([
+        /*region comment based formats*/
+        new IgnoreJumpNode(), // must be prioritized above line comment node
+        new LineCommentNode(),
+        /*endregion commend based formats*/
+        new EndIfNode(),
+        new ElseIfNode(),
+        new ElseNode(),
+        new IfNode(),
+        new IgnoreGuardNode(),
+        /*region commands*/
+        new SetVariableNode(),
+        new DeclareCommand(),
+        new JumpCommand(),
+        new UnvisitCommand(),
+        /*endregion commands*/
+        new NormalLineProcessorNode()
+    ]);
+    /**
+     * process the dialog line by line and return a presentable string
+     * @param dialogDetail
+     */
+    processDialog = (dialogDetail) => {
+        if (!browser) {
+            return ""; // don't process any line in the server
+        }
+        let currentState = new BehaviorState();
+        // split each yarn line
+        return dialogDetail.textContent
+            .trim()
+            .split("\n")
+            .map((line_, index) => {
+            const result = this.processingTree.process({
+                initState: currentState,
+                line: line_.trim(),
+                lineIndex: index
+            });
+            currentState = result.nextState;
+            return result.renderedLine;
+        })
+            .join("\n"); // combine all processed lines
+    };
+}

package/dist/components/dialog_manager/DialogUtils.d.ts

@@ -0,0 +1,5 @@
+declare class _DialogUtils {
+    isNodeVisited: (dialogId: string) => boolean;
+}
+export declare const DialogUtils: _DialogUtils;
+export {};

package/dist/components/dialog_manager/DialogUtils.js

@@ -0,0 +1,8 @@
+import { dialogVariableStore } from "./DialogManagerStore";
+class _DialogUtils {
+    isNodeVisited = (dialogId) => {
+        const value = Number(dialogVariableStore.getItem(`+${dialogId}`));
+        return !isNaN(value) && value > 0;
+    };
+}
+export const DialogUtils = new _DialogUtils();

package/dist/components/dialog_manager/behavior_tree/core/BTreeUtils.d.ts

@@ -0,0 +1,15 @@
+declare class BTreeUtils {
+    /**
+     * peek the top of a stack object with the assumption it's not an empty stack
+     * todo: add possible protection like an assertion
+     * @param stack
+     * @return top of the stack
+     */
+    peek: <T>(stack: T[]) => T;
+    removeQuotes: (value: string) => string;
+    simplifyToken: (oldToken: string) => string;
+    isTrue: (value: string) => boolean;
+    isFalse: (value: string) => boolean;
+}
+export declare const btreeUtils: BTreeUtils;
+export {};

package/dist/components/dialog_manager/behavior_tree/core/BTreeUtils.js

@@ -0,0 +1,34 @@
+class BTreeUtils {
+    /**
+     * peek the top of a stack object with the assumption it's not an empty stack
+     * todo: add possible protection like an assertion
+     * @param stack
+     * @return top of the stack
+     */
+    peek = (stack) => {
+        return stack[stack.length - 1];
+    };
+    removeQuotes = (value) => {
+        return value
+            .replace(/^"/, "") // remove possible " at the start: https://stackoverflow.com/a/2182602
+            .replace(/"$/, ""); // remove possible " at the end: https://stackoverflow.com/a/12249011
+    };
+    simplifyToken = (oldToken) => {
+        if (oldToken[0] == "$") {
+            const value = localStorage.getItem(oldToken);
+            if (value) {
+                return value;
+            }
+            console.error(`Value obtained in local storage false: ${oldToken}`);
+            return "";
+        }
+        return btreeUtils.removeQuotes(oldToken);
+    };
+    isTrue = (value) => {
+        return value.trim().toLowerCase() === "true";
+    };
+    isFalse = (value) => {
+        return value.trim().toLowerCase() === "false";
+    };
+}
+export const btreeUtils = new BTreeUtils();

package/dist/components/dialog_manager/behavior_tree/core/BaseBehaviorResult.d.ts

@@ -0,0 +1,4 @@
+import type { BehaviorStatus } from "./BehaviorStatus";
+export interface BaseBehaviorResult {
+    status: BehaviorStatus;
+}

package/dist/components/dialog_manager/behavior_tree/core/BaseBehaviorResult.js

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

package/dist/components/dialog_manager/behavior_tree/core/BehaviorNode.d.ts

@@ -0,0 +1,3 @@
+export interface BehaviorNode<Argument, Result> {
+    process: (nodeArgs: Argument) => Result;
+}

package/dist/components/dialog_manager/behavior_tree/core/BehaviorNode.js

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

package/dist/components/dialog_manager/behavior_tree/core/BehaviorStatus.d.ts

@@ -0,0 +1,5 @@
+export declare enum BehaviorStatus {
+    Running = 0,
+    Success = 1,
+    Failure = 2
+}

package/dist/components/dialog_manager/behavior_tree/core/BehaviorStatus.js

@@ -0,0 +1,6 @@
+export var BehaviorStatus;
+(function (BehaviorStatus) {
+    BehaviorStatus[BehaviorStatus["Running"] = 0] = "Running";
+    BehaviorStatus[BehaviorStatus["Success"] = 1] = "Success";
+    BehaviorStatus[BehaviorStatus["Failure"] = 2] = "Failure";
+})(BehaviorStatus || (BehaviorStatus = {}));

package/dist/components/dialog_manager/behavior_tree/core/SelectorNode.d.ts

@@ -0,0 +1,12 @@
+import type { BehaviorNode } from "./BehaviorNode";
+import type { BaseBehaviorResult } from "./BaseBehaviorResult";
+/**
+ * Selector is a composite behavior node where it tries to process everything until it
+ * finds a non-failing node
+ */
+export declare abstract class SelectorNode<Argument, Result extends BaseBehaviorResult> implements BehaviorNode<Argument, Result> {
+    nodeList: BehaviorNode<Argument, Result>[];
+    abstract defaultResult: () => Result;
+    protected constructor(nodeList: BehaviorNode<Argument, Result>[]);
+    process(nodeArgs: Argument): Result;
+}

package/dist/components/dialog_manager/behavior_tree/core/SelectorNode.js

@@ -0,0 +1,22 @@
+import { BehaviorStatus } from "./BehaviorStatus";
+/**
+ * Selector is a composite behavior node where it tries to process everything until it
+ * finds a non-failing node
+ */
+export class SelectorNode {
+    nodeList;
+    constructor(nodeList) {
+        this.nodeList = nodeList;
+    }
+    process(nodeArgs) {
+        let finalResult = this.defaultResult();
+        for (const node of this.nodeList) {
+            const currentResult = node.process(nodeArgs);
+            if (currentResult.status !== BehaviorStatus.Failure) {
+                finalResult = currentResult;
+                break;
+            }
+        }
+        return finalResult;
+    }
+}

package/dist/components/dialog_manager/behavior_tree/expression/ExpressionArguments.d.ts

@@ -0,0 +1,5 @@
+import type { ExpressionState } from "./ExpressionState";
+export interface ExpressionArguments {
+    token: string;
+    initState: ExpressionState;
+}

package/dist/components/dialog_manager/behavior_tree/expression/ExpressionArguments.js

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

package/dist/components/dialog_manager/behavior_tree/expression/ExpressionBehaviorNode.d.ts

@@ -0,0 +1,4 @@
+import type { BehaviorNode } from "../core/BehaviorNode";
+import type { ExpressionArguments } from "./ExpressionArguments";
+import type { ExpressionResult } from "./ExpressionResult";
+export type ExpressionBehaviorNode = BehaviorNode<ExpressionArguments, ExpressionResult>;

package/dist/components/dialog_manager/behavior_tree/expression/ExpressionBehaviorNode.js

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

package/dist/components/dialog_manager/behavior_tree/expression/ExpressionEvaluator.d.ts

@@ -0,0 +1,15 @@
+import { ExpressionSelectorNode } from "./ExpressionSelectorNode";
+declare class ExpressionEvaluator {
+    evaluatorTree: ExpressionSelectorNode;
+    isNumeric: (str: string) => boolean;
+    getPrecedence: (token: string) => number;
+    evaluateFreeform: (line: string, prefix: string) => string[];
+    /**
+     * evaluates a yarn if or elseif statement
+     * @param line is the current line being evaluated
+     * @param prefix is either "<<if" or "<<elseif"
+     */
+    evaluate: (line: string, prefix: string) => boolean;
+}
+export declare const expressionEvaluator: ExpressionEvaluator;
+export {};