@babylonjs/core 7.51.1 → 7.51.2

package/FlowGraph/flowGraphExecutionBlockWithOutSignal.d.ts

@@ -2,14 +2,14 @@ import type { IFlowGraphBlockConfiguration } from "./flowGraphBlock";
 import { FlowGraphExecutionBlock } from "./flowGraphExecutionBlock";
 import type { FlowGraphSignalConnection } from "./flowGraphSignalConnection";
 /**
- * @experimental
  * An execution block that has an out signal. This signal is triggered when the synchronous execution of this block is done.
  * Most execution blocks will inherit from this, except for the ones that have multiple signals to be triggered.
  * (such as if blocks)
  */
 export declare abstract class FlowGraphExecutionBlockWithOutSignal extends FlowGraphExecutionBlock {
     /**
-     * Output connection: The signal that is triggered when the execution of this block is done.
+     * Output connection: The signal that is synchronous triggered when the execution of this block is done.
+     * Note that is case of events or async you might want to use the `done` signal instead.
      */
     readonly out: FlowGraphSignalConnection;
     protected constructor(config?: IFlowGraphBlockConfiguration);

package/FlowGraph/flowGraphExecutionBlockWithOutSignal.js

@@ -1,6 +1,5 @@
 import { FlowGraphExecutionBlock } from "./flowGraphExecutionBlock.js";
 /**
- * @experimental
  * An execution block that has an out signal. This signal is triggered when the synchronous execution of this block is done.
  * Most execution blocks will inherit from this, except for the ones that have multiple signals to be triggered.
  * (such as if blocks)

package/FlowGraph/flowGraphExecutionBlockWithOutSignal.js.map

@@ -1 +1 @@
-{"version":3,"file":"flowGraphExecutionBlockWithOutSignal.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraphExecutionBlockWithOutSignal.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAGpE;;;;;GAKG;AACH,MAAM,OAAgB,oCAAqC,SAAQ,uBAAuB;IAMtF,YAAsB,MAAqC;QACvD,KAAK,CAAC,MAAM,CAAC,CAAC;QACd,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACjD,CAAC;CACJ","sourcesContent":["import type { IFlowGraphBlockConfiguration } from \"./flowGraphBlock\";\r\nimport { FlowGraphExecutionBlock } from \"./flowGraphExecutionBlock\";\r\nimport type { FlowGraphSignalConnection } from \"./flowGraphSignalConnection\";\r\n\r\n/**\r\n * @experimental\r\n * An execution block that has an out signal. This signal is triggered when the synchronous execution of this block is done.\r\n * Most execution blocks will inherit from this, except for the ones that have multiple signals to be triggered.\r\n * (such as if blocks)\r\n */\r\nexport abstract class FlowGraphExecutionBlockWithOutSignal extends FlowGraphExecutionBlock {\r\n    /**\r\n     * Output connection: The signal that is triggered when the execution of this block is done.\r\n     */\r\n    public readonly out: FlowGraphSignalConnection;\r\n\r\n    protected constructor(config?: IFlowGraphBlockConfiguration) {\r\n        super(config);\r\n        this.out = this._registerSignalOutput(\"out\");\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"flowGraphExecutionBlockWithOutSignal.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraphExecutionBlockWithOutSignal.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAGpE;;;;GAIG;AACH,MAAM,OAAgB,oCAAqC,SAAQ,uBAAuB;IAOtF,YAAsB,MAAqC;QACvD,KAAK,CAAC,MAAM,CAAC,CAAC;QACd,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACjD,CAAC;CACJ","sourcesContent":["import type { IFlowGraphBlockConfiguration } from \"./flowGraphBlock\";\r\nimport { FlowGraphExecutionBlock } from \"./flowGraphExecutionBlock\";\r\nimport type { FlowGraphSignalConnection } from \"./flowGraphSignalConnection\";\r\n\r\n/**\r\n * An execution block that has an out signal. This signal is triggered when the synchronous execution of this block is done.\r\n * Most execution blocks will inherit from this, except for the ones that have multiple signals to be triggered.\r\n * (such as if blocks)\r\n */\r\nexport abstract class FlowGraphExecutionBlockWithOutSignal extends FlowGraphExecutionBlock {\r\n    /**\r\n     * Output connection: The signal that is synchronous triggered when the execution of this block is done.\r\n     * Note that is case of events or async you might want to use the `done` signal instead.\r\n     */\r\n    public readonly out: FlowGraphSignalConnection;\r\n\r\n    protected constructor(config?: IFlowGraphBlockConfiguration) {\r\n        super(config);\r\n        this.out = this._registerSignalOutput(\"out\");\r\n    }\r\n}\r\n"]}

package/FlowGraph/flowGraphLogger.d.ts

@@ -0,0 +1,60 @@
+export declare enum FlowGraphAction {
+    ExecuteBlock = "ExecuteBlock",
+    ExecuteEvent = "ExecuteEvent",
+    TriggerConnection = "TriggerConnection",
+    ContextVariableSet = "ContextVariableSet",
+    GlobalVariableSet = "GlobalVariableSet",
+    GlobalVariableDelete = "GlobalVariableDelete",
+    GlobalVariableGet = "GlobalVariableGet",
+    AddConnection = "AddConnection",
+    GetConnectionValue = "GetConnectionValue",
+    SetConnectionValue = "SetConnectionValue",
+    ActivateSignal = "ActivateSignal",
+    ContextVariableGet = "ContextVariableGet"
+}
+/**
+ * An item in the flow graph log.
+ */
+export interface IFlowGraphLogItem {
+    /**
+     * The time of the log item.
+     */
+    time?: number;
+    /**
+     * The class that triggered the log.
+     */
+    className: string;
+    /**
+     * The unique id of the block/module that triggered the log.
+     */
+    uniqueId: string;
+    /**
+     * The action that was logged.
+     */
+    action: FlowGraphAction;
+    /**
+     * The payload of the log
+     * This can be any data that is relevant to the action.
+     * For example, the value of a connection, the value of a variable, etc.
+     * This is optional.
+     */
+    payload?: any;
+}
+/**
+ * This class will be responsible of logging the flow graph activity.
+ * Note that using this class might reduce performance, as it will log every action, according to the configuration.
+ * It attaches to a flow graph and uses meta-programming to replace the methods of the flow graph to add logging abilities.
+ */
+export declare class FlowGraphLogger {
+    /**
+     * Whether to log to the console.
+     */
+    logToConsole: boolean;
+    /**
+     * The log cache of the flow graph.
+     * Each item is a logged item, in order of execution.
+     */
+    log: IFlowGraphLogItem[];
+    addLogItem(item: IFlowGraphLogItem): void;
+    getItemsOfType(action: FlowGraphAction): IFlowGraphLogItem[];
+}

package/FlowGraph/flowGraphLogger.js

@@ -0,0 +1,53 @@
+import { Logger } from "../Misc/logger.js";
+export var FlowGraphAction;
+(function (FlowGraphAction) {
+    FlowGraphAction["ExecuteBlock"] = "ExecuteBlock";
+    FlowGraphAction["ExecuteEvent"] = "ExecuteEvent";
+    FlowGraphAction["TriggerConnection"] = "TriggerConnection";
+    FlowGraphAction["ContextVariableSet"] = "ContextVariableSet";
+    FlowGraphAction["GlobalVariableSet"] = "GlobalVariableSet";
+    FlowGraphAction["GlobalVariableDelete"] = "GlobalVariableDelete";
+    FlowGraphAction["GlobalVariableGet"] = "GlobalVariableGet";
+    FlowGraphAction["AddConnection"] = "AddConnection";
+    FlowGraphAction["GetConnectionValue"] = "GetConnectionValue";
+    FlowGraphAction["SetConnectionValue"] = "SetConnectionValue";
+    FlowGraphAction["ActivateSignal"] = "ActivateSignal";
+    FlowGraphAction["ContextVariableGet"] = "ContextVariableGet";
+})(FlowGraphAction || (FlowGraphAction = {}));
+/**
+ * This class will be responsible of logging the flow graph activity.
+ * Note that using this class might reduce performance, as it will log every action, according to the configuration.
+ * It attaches to a flow graph and uses meta-programming to replace the methods of the flow graph to add logging abilities.
+ */
+export class FlowGraphLogger {
+    constructor() {
+        /**
+         * Whether to log to the console.
+         */
+        this.logToConsole = false;
+        /**
+         * The log cache of the flow graph.
+         * Each item is a logged item, in order of execution.
+         */
+        this.log = [];
+    }
+    addLogItem(item) {
+        if (!item.time) {
+            item.time = Date.now();
+        }
+        this.log.push(item);
+        if (this.logToConsole) {
+            const value = item.payload?.value;
+            if (typeof value === "object" && value.getClassName) {
+                Logger.Log(`[FGLog] ${item.className}:${item.uniqueId.split("-")[0]} ${item.action} - ${JSON.stringify(value.getClassName())}: ${value.toString()}`);
+            }
+            else {
+                Logger.Log(`[FGLog] ${item.className}:${item.uniqueId.split("-")[0]} ${item.action} - ${JSON.stringify(item.payload)}`);
+            }
+        }
+    }
+    getItemsOfType(action) {
+        return this.log.filter((i) => i.action === action);
+    }
+}
+//# sourceMappingURL=flowGraphLogger.js.map

package/FlowGraph/flowGraphLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowGraphLogger.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraphLogger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,0BAAyB;AAE1C,MAAM,CAAN,IAAkB,eAajB;AAbD,WAAkB,eAAe;IAC7B,gDAA6B,CAAA;IAC7B,gDAA6B,CAAA;IAC7B,0DAAuC,CAAA;IACvC,4DAAyC,CAAA;IACzC,0DAAuC,CAAA;IACvC,gEAA6C,CAAA;IAC7C,0DAAuC,CAAA;IACvC,kDAA+B,CAAA;IAC/B,4DAAyC,CAAA;IACzC,4DAAyC,CAAA;IACzC,oDAAiC,CAAA;IACjC,4DAAyC,CAAA;AAC7C,CAAC,EAbiB,eAAe,KAAf,eAAe,QAahC;AA+BD;;;;GAIG;AACH,MAAM,OAAO,eAAe;IAA5B;QACI;;WAEG;QACI,iBAAY,GAAY,KAAK,CAAC;QAErC;;;WAGG;QACI,QAAG,GAAwB,EAAE,CAAC;IAoBzC,CAAC;IAlBU,UAAU,CAAC,IAAuB;QACrC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACb,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC3B,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC;YAClC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;gBAClD,MAAM,CAAC,GAAG,CAAC,WAAW,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,KAAK,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;YACzJ,CAAC;iBAAM,CAAC;gBACJ,MAAM,CAAC,GAAG,CAAC,WAAW,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YAC5H,CAAC;QACL,CAAC;IACL,CAAC;IAEM,cAAc,CAAC,MAAuB;QACzC,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC;IACvD,CAAC;CACJ","sourcesContent":["import { Logger } from \"core/Misc/logger\";\n\nexport const enum FlowGraphAction {\n    ExecuteBlock = \"ExecuteBlock\",\n    ExecuteEvent = \"ExecuteEvent\",\n    TriggerConnection = \"TriggerConnection\",\n    ContextVariableSet = \"ContextVariableSet\",\n    GlobalVariableSet = \"GlobalVariableSet\",\n    GlobalVariableDelete = \"GlobalVariableDelete\",\n    GlobalVariableGet = \"GlobalVariableGet\",\n    AddConnection = \"AddConnection\",\n    GetConnectionValue = \"GetConnectionValue\",\n    SetConnectionValue = \"SetConnectionValue\",\n    ActivateSignal = \"ActivateSignal\",\n    ContextVariableGet = \"ContextVariableGet\",\n}\n\n/**\n * An item in the flow graph log.\n */\nexport interface IFlowGraphLogItem {\n    /**\n     * The time of the log item.\n     */\n    time?: number;\n    /**\n     * The class that triggered the log.\n     */\n    className: string;\n    /**\n     * The unique id of the block/module that triggered the log.\n     */\n    uniqueId: string;\n    /**\n     * The action that was logged.\n     */\n    action: FlowGraphAction;\n    /**\n     * The payload of the log\n     * This can be any data that is relevant to the action.\n     * For example, the value of a connection, the value of a variable, etc.\n     * This is optional.\n     */\n    payload?: any;\n}\n\n/**\n * This class will be responsible of logging the flow graph activity.\n * Note that using this class might reduce performance, as it will log every action, according to the configuration.\n * It attaches to a flow graph and uses meta-programming to replace the methods of the flow graph to add logging abilities.\n */\nexport class FlowGraphLogger {\n    /**\n     * Whether to log to the console.\n     */\n    public logToConsole: boolean = false;\n\n    /**\n     * The log cache of the flow graph.\n     * Each item is a logged item, in order of execution.\n     */\n    public log: IFlowGraphLogItem[] = [];\n\n    public addLogItem(item: IFlowGraphLogItem) {\n        if (!item.time) {\n            item.time = Date.now();\n        }\n        this.log.push(item);\n        if (this.logToConsole) {\n            const value = item.payload?.value;\n            if (typeof value === \"object\" && value.getClassName) {\n                Logger.Log(`[FGLog] ${item.className}:${item.uniqueId.split(\"-\")[0]} ${item.action} - ${JSON.stringify(value.getClassName())}: ${value.toString()}`);\n            } else {\n                Logger.Log(`[FGLog] ${item.className}:${item.uniqueId.split(\"-\")[0]} ${item.action} - ${JSON.stringify(item.payload)}`);\n            }\n        }\n    }\n\n    public getItemsOfType(action: FlowGraphAction): IFlowGraphLogItem[] {\n        return this.log.filter((i) => i.action === action);\n    }\n}\n"]}

package/FlowGraph/flowGraphParser.d.ts

@@ -0,0 +1,85 @@
+import type { FlowGraph, IFlowGraphParseOptions } from "./flowGraph";
+import type { FlowGraphBlock, IFlowGraphBlockParseOptions } from "./flowGraphBlock";
+import type { FlowGraphContext, IFlowGraphContextParseOptions } from "./flowGraphContext";
+import type { FlowGraphCoordinatorParseOptions } from "./flowGraphCoordinator";
+import { FlowGraphCoordinator } from "./flowGraphCoordinator";
+import type { FlowGraphDataConnection } from "./flowGraphDataConnection";
+import type { FlowGraphSignalConnection } from "./flowGraphSignalConnection";
+import type { ISerializedFlowGraph, ISerializedFlowGraphBlock, ISerializedFlowGraphContext } from "./typeDefinitions";
+import type { FlowGraphConnection } from "./flowGraphConnection";
+/**
+ * Given a list of blocks, find an output data connection that has a specific unique id
+ * @param blocks a list of flow graph blocks
+ * @param uniqueId the unique id of a connection
+ * @returns the connection that has this unique id. throws an error if none was found
+ */
+export declare function GetDataOutConnectionByUniqueId(blocks: FlowGraphBlock[], uniqueId: string): FlowGraphDataConnection<any>;
+/**
+ * Given a list of blocks, find an input signal connection that has a specific unique id
+ * @param blocks a list of flow graph blocks
+ * @param uniqueId the unique id of a connection
+ * @returns the connection that has this unique id. throws an error if none was found
+ */
+export declare function GetSignalInConnectionByUniqueId(blocks: FlowGraphBlock[], uniqueId: string): FlowGraphSignalConnection;
+/**
+ * Parses a serialized coordinator.
+ * @param serializedObject the object to parse
+ * @param options the options to use when parsing
+ * @returns the parsed coordinator
+ */
+export declare function ParseCoordinatorAsync(serializedObject: any, options: FlowGraphCoordinatorParseOptions): Promise<FlowGraphCoordinator>;
+/**
+ * Parses a graph from a given serialization object
+ * @param serializationObject the object where the values are written
+ * @param options options for parsing the graph
+ * @returns the parsed graph
+ */
+export declare function ParseFlowGraphAsync(serializationObject: ISerializedFlowGraph, options: IFlowGraphParseOptions): Promise<FlowGraph>;
+/**
+ * Parses a graph from a given serialization object
+ * @param serializationObject the object where the values are written
+ * @param options options for parsing the graph
+ * @param resolvedClasses the resolved classes for the blocks
+ * @returns the parsed graph
+ */
+export declare function ParseFlowGraph(serializationObject: ISerializedFlowGraph, options: IFlowGraphParseOptions, resolvedClasses: (typeof FlowGraphBlock)[]): FlowGraph;
+/**
+ * Parses a context
+ * @param serializationObject the object containing the context serialization values
+ * @param options the options for parsing the context
+ * @param rightHanded whether the serialized data is right handed
+ * @returns
+ */
+export declare function ParseFlowGraphContext(serializationObject: ISerializedFlowGraphContext, options: IFlowGraphContextParseOptions, rightHanded?: boolean): FlowGraphContext;
+/**
+ * Parses a block from a serialization object
+ * This function is async due to the factory method that is used to create the block's class. If you load the class externally use ParseBlockWithClassType
+ * @param serializationObject the object to parse from
+ * @param parseOptions options for parsing the block
+ * @returns the parsed block
+ */
+export declare function ParseBlockAsync(serializationObject: ISerializedFlowGraphBlock, parseOptions: IFlowGraphBlockParseOptions): Promise<FlowGraphBlock>;
+/**
+ * Parses a block from a serialization object
+ * @param serializationObject the object to parse from
+ * @param parseOptions options for parsing the block
+ * @param classType the class type of the block. This is used when the class is not loaded asynchronously
+ * @returns the parsed block
+ */
+export declare function ParseFlowGraphBlockWithClassType(serializationObject: ISerializedFlowGraphBlock, parseOptions: IFlowGraphBlockParseOptions, classType: typeof FlowGraphBlock): FlowGraphBlock;
+/**
+ * Parses a connection from an object
+ * @param serializationObject the object to parse from.
+ * @param ownerBlock the block that owns the connection.
+ * @param classType the class type of the connection.
+ * @returns the parsed connection.
+ */
+export declare function ParseGraphConnectionWithClassType<BlockT extends FlowGraphBlock>(serializationObject: any | undefined, ownerBlock: BlockT, classType: typeof FlowGraphConnection): FlowGraphConnection<BlockT, import("./flowGraphConnection").IConnectable>;
+/**
+ * Parses a data connection from a serialized object.
+ * @param serializationObject the object to parse from
+ * @param ownerBlock the block that owns the connection
+ * @param classType the class type of the data connection
+ * @returns the parsed connection
+ */
+export declare function ParseGraphDataConnection(serializationObject: any, ownerBlock: FlowGraphBlock, classType: typeof FlowGraphDataConnection): FlowGraphDataConnection<any>;

package/FlowGraph/flowGraphParser.js

@@ -0,0 +1,271 @@
+import { blockFactory } from "./Blocks/flowGraphBlockFactory.js";
+import { FlowGraphCoordinator } from "./flowGraphCoordinator.js";
+import { FlowGraphEventBlock } from "./flowGraphEventBlock.js";
+import { FlowGraphExecutionBlock } from "./flowGraphExecutionBlock.js";
+import { defaultValueParseFunction, needsPathConverter } from "./serialization.js";
+import { getRichTypeByFlowGraphType, RichType } from "./flowGraphRichTypes.js";
+/**
+ * Given a list of blocks, find an output data connection that has a specific unique id
+ * @param blocks a list of flow graph blocks
+ * @param uniqueId the unique id of a connection
+ * @returns the connection that has this unique id. throws an error if none was found
+ */
+export function GetDataOutConnectionByUniqueId(blocks, uniqueId) {
+    for (const block of blocks) {
+        for (const dataOut of block.dataOutputs) {
+            if (dataOut.uniqueId === uniqueId) {
+                return dataOut;
+            }
+        }
+    }
+    throw new Error("Could not find data out connection with unique id " + uniqueId);
+}
+/**
+ * Given a list of blocks, find an input signal connection that has a specific unique id
+ * @param blocks a list of flow graph blocks
+ * @param uniqueId the unique id of a connection
+ * @returns the connection that has this unique id. throws an error if none was found
+ */
+export function GetSignalInConnectionByUniqueId(blocks, uniqueId) {
+    for (const block of blocks) {
+        if (block instanceof FlowGraphExecutionBlock) {
+            for (const signalIn of block.signalInputs) {
+                if (signalIn.uniqueId === uniqueId) {
+                    return signalIn;
+                }
+            }
+        }
+    }
+    throw new Error("Could not find signal in connection with unique id " + uniqueId);
+}
+/**
+ * Parses a serialized coordinator.
+ * @param serializedObject the object to parse
+ * @param options the options to use when parsing
+ * @returns the parsed coordinator
+ */
+export async function ParseCoordinatorAsync(serializedObject, options) {
+    const valueParseFunction = options.valueParseFunction ?? defaultValueParseFunction;
+    const coordinator = new FlowGraphCoordinator({ scene: options.scene });
+    await options.scene.whenReadyAsync();
+    // if custom default values are defined, set them in the global context
+    if (serializedObject._defaultValues) {
+        for (const key in serializedObject._defaultValues) {
+            // key is the FlowGraphType, value is the default value
+            const value = serializedObject._defaultValues[key];
+            getRichTypeByFlowGraphType(key).defaultValue = value;
+        }
+    }
+    // async-parse the flow graphs. This can be done in parallel
+    await Promise.all(serializedObject._flowGraphs?.map((serializedGraph) => ParseFlowGraphAsync(serializedGraph, { coordinator, valueParseFunction, pathConverter: options.pathConverter })));
+    return coordinator;
+}
+/**
+ * Parses a graph from a given serialization object
+ * @param serializationObject the object where the values are written
+ * @param options options for parsing the graph
+ * @returns the parsed graph
+ */
+export async function ParseFlowGraphAsync(serializationObject, options) {
+    // get all classes types needed for the blocks using the block factory
+    const resolvedClasses = await Promise.all(serializationObject.allBlocks.map(async (serializedBlock) => {
+        const classFactory = blockFactory(serializedBlock.className);
+        return classFactory();
+    }));
+    // async will be used when we start using the block async factory
+    return ParseFlowGraph(serializationObject, options, resolvedClasses);
+}
+/**
+ * Parses a graph from a given serialization object
+ * @param serializationObject the object where the values are written
+ * @param options options for parsing the graph
+ * @param resolvedClasses the resolved classes for the blocks
+ * @returns the parsed graph
+ */
+export function ParseFlowGraph(serializationObject, options, resolvedClasses) {
+    const graph = options.coordinator.createGraph();
+    const blocks = [];
+    const valueParseFunction = options.valueParseFunction ?? defaultValueParseFunction;
+    // Parse all blocks
+    // for (const serializedBlock of serializationObject.allBlocks) {
+    for (let i = 0; i < serializationObject.allBlocks.length; i++) {
+        const serializedBlock = serializationObject.allBlocks[i];
+        const block = ParseFlowGraphBlockWithClassType(serializedBlock, { scene: options.coordinator.config.scene, pathConverter: options.pathConverter, assetsContainer: options.coordinator.config.scene, valueParseFunction }, resolvedClasses[i]);
+        blocks.push(block);
+        if (block instanceof FlowGraphEventBlock) {
+            graph.addEventBlock(block);
+        }
+    }
+    // After parsing all blocks, connect them
+    for (const block of blocks) {
+        for (const dataIn of block.dataInputs) {
+            for (const serializedConnection of dataIn.connectedPointIds) {
+                const connection = GetDataOutConnectionByUniqueId(blocks, serializedConnection);
+                dataIn.connectTo(connection);
+            }
+        }
+        if (block instanceof FlowGraphExecutionBlock) {
+            for (const signalOut of block.signalOutputs) {
+                for (const serializedConnection of signalOut.connectedPointIds) {
+                    const connection = GetSignalInConnectionByUniqueId(blocks, serializedConnection);
+                    signalOut.connectTo(connection);
+                }
+            }
+        }
+    }
+    for (const serializedContext of serializationObject.executionContexts) {
+        ParseFlowGraphContext(serializedContext, { graph, valueParseFunction }, serializationObject.rightHanded);
+    }
+    return graph;
+}
+/**
+ * Parses a context
+ * @param serializationObject the object containing the context serialization values
+ * @param options the options for parsing the context
+ * @param rightHanded whether the serialized data is right handed
+ * @returns
+ */
+export function ParseFlowGraphContext(serializationObject, options, rightHanded) {
+    const result = options.graph.createContext();
+    if (serializationObject.enableLogging) {
+        result.enableLogging = true;
+    }
+    result.treatDataAsRightHanded = rightHanded || false;
+    const valueParseFunction = options.valueParseFunction ?? defaultValueParseFunction;
+    result.uniqueId = serializationObject.uniqueId;
+    const scene = result.getScene();
+    // check if assets context is available
+    if (serializationObject._assetsContext) {
+        const ac = serializationObject._assetsContext;
+        const assetsContext = {
+            meshes: ac.meshes?.map((m) => scene.getMeshById(m)),
+            lights: ac.lights?.map((l) => scene.getLightByName(l)),
+            cameras: ac.cameras?.map((c) => scene.getCameraByName(c)),
+            materials: ac.materials?.map((m) => scene.getMaterialById(m)),
+            textures: ac.textures?.map((t) => scene.getTextureByName(t)),
+            animations: ac.animations?.map((a) => scene.animations.find((anim) => anim.name === a)),
+            skeletons: ac.skeletons?.map((s) => scene.getSkeletonByName(s)),
+            particleSystems: ac.particleSystems?.map((ps) => scene.getParticleSystemById(ps)),
+            animationGroups: ac.animationGroups?.map((ag) => scene.getAnimationGroupByName(ag)),
+            transformNodes: ac.transformNodes?.map((tn) => scene.getTransformNodeById(tn)),
+            rootNodes: [],
+            multiMaterials: [],
+            morphTargetManagers: [],
+            geometries: [],
+            actionManagers: [],
+            environmentTexture: null,
+            postProcesses: [],
+            sounds: null,
+            effectLayers: [],
+            layers: [],
+            reflectionProbes: [],
+            lensFlareSystems: [],
+            proceduralTextures: [],
+            getNodes: function () {
+                throw new Error("Function not implemented.");
+            },
+        };
+        result.assetsContext = assetsContext;
+    }
+    for (const key in serializationObject._userVariables) {
+        const value = valueParseFunction(key, serializationObject._userVariables, result.assetsContext, scene);
+        result.userVariables[key] = value;
+    }
+    for (const key in serializationObject._connectionValues) {
+        const value = valueParseFunction(key, serializationObject._connectionValues, result.assetsContext, scene);
+        result._setConnectionValueByKey(key, value);
+    }
+    return result;
+}
+/**
+ * Parses a block from a serialization object
+ * This function is async due to the factory method that is used to create the block's class. If you load the class externally use ParseBlockWithClassType
+ * @param serializationObject the object to parse from
+ * @param parseOptions options for parsing the block
+ * @returns the parsed block
+ */
+export async function ParseBlockAsync(serializationObject, parseOptions) {
+    const classFactory = blockFactory(serializationObject.className);
+    const classType = await classFactory();
+    return ParseFlowGraphBlockWithClassType(serializationObject, parseOptions, classType);
+}
+/**
+ * Parses a block from a serialization object
+ * @param serializationObject the object to parse from
+ * @param parseOptions options for parsing the block
+ * @param classType the class type of the block. This is used when the class is not loaded asynchronously
+ * @returns the parsed block
+ */
+export function ParseFlowGraphBlockWithClassType(serializationObject, parseOptions, classType) {
+    const parsedConfig = {};
+    const valueParseFunction = parseOptions.valueParseFunction ?? defaultValueParseFunction;
+    if (serializationObject.config) {
+        for (const key in serializationObject.config) {
+            parsedConfig[key] = valueParseFunction(key, serializationObject.config, parseOptions.assetsContainer || parseOptions.scene, parseOptions.scene);
+        }
+    }
+    if (needsPathConverter(serializationObject.className)) {
+        if (!parseOptions.pathConverter) {
+            throw new Error("Path converter is required for this block");
+        }
+        parsedConfig.pathConverter = parseOptions.pathConverter;
+    }
+    const obj = new classType(parsedConfig);
+    obj.uniqueId = serializationObject.uniqueId;
+    for (let i = 0; i < serializationObject.dataInputs.length; i++) {
+        const dataInput = obj.getDataInput(serializationObject.dataInputs[i].name);
+        if (dataInput) {
+            dataInput.deserialize(serializationObject.dataInputs[i]);
+        }
+        else {
+            throw new Error("Could not find data input with name " + serializationObject.dataInputs[i].name + " in block " + serializationObject.className);
+        }
+    }
+    for (let i = 0; i < serializationObject.dataOutputs.length; i++) {
+        const dataOutput = obj.getDataOutput(serializationObject.dataOutputs[i].name);
+        if (dataOutput) {
+            dataOutput.deserialize(serializationObject.dataOutputs[i]);
+        }
+        else {
+            throw new Error("Could not find data output with name " + serializationObject.dataOutputs[i].name + " in block " + serializationObject.className);
+        }
+    }
+    obj.metadata = serializationObject.metadata;
+    obj.deserialize && obj.deserialize(serializationObject);
+    return obj;
+}
+/**
+ * Parses a connection from an object
+ * @param serializationObject the object to parse from.
+ * @param ownerBlock the block that owns the connection.
+ * @param classType the class type of the connection.
+ * @returns the parsed connection.
+ */
+export function ParseGraphConnectionWithClassType(serializationObject = {}, ownerBlock, classType) {
+    const connection = new classType(serializationObject.name, serializationObject._connectionType, ownerBlock);
+    connection.deserialize(serializationObject);
+    return connection;
+}
+/**
+ * Parses a data connection from a serialized object.
+ * @param serializationObject the object to parse from
+ * @param ownerBlock the block that owns the connection
+ * @param classType the class type of the data connection
+ * @returns the parsed connection
+ */
+export function ParseGraphDataConnection(serializationObject, ownerBlock, classType) {
+    const richType = ParseRichType(serializationObject.richType);
+    const defaultValue = serializationObject.defaultValue;
+    const connection = new classType(serializationObject.name, serializationObject._connectionType, ownerBlock, richType, defaultValue, !!serializationObject._optional);
+    connection.deserialize(serializationObject);
+    return connection;
+}
+/**
+ * Parses a rich type from a serialization object.
+ * @param serializationObject a serialization object
+ * @returns the parsed rich type
+ */
+function ParseRichType(serializationObject) {
+    return new RichType(serializationObject.typeName, serializationObject.defaultValue);
+}
+//# sourceMappingURL=flowGraphParser.js.map

package/FlowGraph/flowGraphParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowGraphParser.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraphParser.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IAssetContainer } from \"core/IAssetContainer\";\nimport { blockFactory } from \"./Blocks/flowGraphBlockFactory\";\nimport type { FlowGraphBlockNames } from \"./Blocks/flowGraphBlockNames\";\nimport type { FlowGraph, IFlowGraphParseOptions } from \"./flowGraph\";\nimport type { FlowGraphBlock, IFlowGraphBlockParseOptions } from \"./flowGraphBlock\";\nimport type { FlowGraphContext, IFlowGraphContextParseOptions } from \"./flowGraphContext\";\nimport type { FlowGraphCoordinatorParseOptions } from \"./flowGraphCoordinator\";\nimport { FlowGraphCoordinator } from \"./flowGraphCoordinator\";\nimport type { FlowGraphDataConnection } from \"./flowGraphDataConnection\";\nimport { FlowGraphEventBlock } from \"./flowGraphEventBlock\";\nimport { FlowGraphExecutionBlock } from \"./flowGraphExecutionBlock\";\nimport type { FlowGraphSignalConnection } from \"./flowGraphSignalConnection\";\nimport { defaultValueParseFunction, needsPathConverter } from \"./serialization\";\nimport type { ISerializedFlowGraph, ISerializedFlowGraphBlock, ISerializedFlowGraphContext } from \"./typeDefinitions\";\nimport type { Node } from \"core/node\";\nimport { getRichTypeByFlowGraphType, RichType } from \"./flowGraphRichTypes\";\nimport type { FlowGraphConnection } from \"./flowGraphConnection\";\n\n/**\n * Given a list of blocks, find an output data connection that has a specific unique id\n * @param blocks a list of flow graph blocks\n * @param uniqueId the unique id of a connection\n * @returns the connection that has this unique id. throws an error if none was found\n */\nexport function GetDataOutConnectionByUniqueId(blocks: FlowGraphBlock[], uniqueId: string): FlowGraphDataConnection<any> {\n    for (const block of blocks) {\n        for (const dataOut of block.dataOutputs) {\n            if (dataOut.uniqueId === uniqueId) {\n                return dataOut;\n            }\n        }\n    }\n    throw new Error(\"Could not find data out connection with unique id \" + uniqueId);\n}\n\n/**\n * Given a list of blocks, find an input signal connection that has a specific unique id\n * @param blocks a list of flow graph blocks\n * @param uniqueId the unique id of a connection\n * @returns the connection that has this unique id. throws an error if none was found\n */\nexport function GetSignalInConnectionByUniqueId(blocks: FlowGraphBlock[], uniqueId: string): FlowGraphSignalConnection {\n    for (const block of blocks) {\n        if (block instanceof FlowGraphExecutionBlock) {\n            for (const signalIn of block.signalInputs) {\n                if (signalIn.uniqueId === uniqueId) {\n                    return signalIn;\n                }\n            }\n        }\n    }\n    throw new Error(\"Could not find signal in connection with unique id \" + uniqueId);\n}\n\n/**\n * Parses a serialized coordinator.\n * @param serializedObject the object to parse\n * @param options the options to use when parsing\n * @returns the parsed coordinator\n */\nexport async function ParseCoordinatorAsync(serializedObject: any, options: FlowGraphCoordinatorParseOptions) {\n    const valueParseFunction = options.valueParseFunction ?? defaultValueParseFunction;\n    const coordinator = new FlowGraphCoordinator({ scene: options.scene });\n\n    await options.scene.whenReadyAsync();\n    // if custom default values are defined, set them in the global context\n    if (serializedObject._defaultValues) {\n        for (const key in serializedObject._defaultValues) {\n            // key is the FlowGraphType, value is the default value\n            const value = serializedObject._defaultValues[key];\n            getRichTypeByFlowGraphType(key).defaultValue = value;\n        }\n    }\n    // async-parse the flow graphs. This can be done in parallel\n    await Promise.all(\n        serializedObject._flowGraphs?.map((serializedGraph: any) => ParseFlowGraphAsync(serializedGraph, { coordinator, valueParseFunction, pathConverter: options.pathConverter }))\n    );\n    return coordinator;\n}\n\n/**\n * Parses a graph from a given serialization object\n * @param serializationObject the object where the values are written\n * @param options options for parsing the graph\n * @returns the parsed graph\n */\nexport async function ParseFlowGraphAsync(serializationObject: ISerializedFlowGraph, options: IFlowGraphParseOptions): Promise<FlowGraph> {\n    // get all classes types needed for the blocks using the block factory\n    const resolvedClasses = await Promise.all(\n        serializationObject.allBlocks.map(async (serializedBlock) => {\n            const classFactory = blockFactory(serializedBlock.className as FlowGraphBlockNames);\n            return classFactory();\n        })\n    );\n    // async will be used when we start using the block async factory\n    return ParseFlowGraph(serializationObject, options, resolvedClasses);\n}\n\n/**\n * Parses a graph from a given serialization object\n * @param serializationObject the object where the values are written\n * @param options options for parsing the graph\n * @param resolvedClasses the resolved classes for the blocks\n * @returns the parsed graph\n */\nexport function ParseFlowGraph(serializationObject: ISerializedFlowGraph, options: IFlowGraphParseOptions, resolvedClasses: (typeof FlowGraphBlock)[]) {\n    const graph = options.coordinator.createGraph();\n    const blocks: FlowGraphBlock[] = [];\n    const valueParseFunction = options.valueParseFunction ?? defaultValueParseFunction;\n    // Parse all blocks\n    // for (const serializedBlock of serializationObject.allBlocks) {\n    for (let i = 0; i < serializationObject.allBlocks.length; i++) {\n        const serializedBlock = serializationObject.allBlocks[i];\n        const block = ParseFlowGraphBlockWithClassType(\n            serializedBlock,\n            { scene: options.coordinator.config.scene, pathConverter: options.pathConverter, assetsContainer: options.coordinator.config.scene, valueParseFunction },\n            resolvedClasses[i]\n        );\n        blocks.push(block);\n        if (block instanceof FlowGraphEventBlock) {\n            graph.addEventBlock(block);\n        }\n    }\n    // After parsing all blocks, connect them\n    for (const block of blocks) {\n        for (const dataIn of block.dataInputs) {\n            for (const serializedConnection of dataIn.connectedPointIds) {\n                const connection = GetDataOutConnectionByUniqueId(blocks, serializedConnection);\n                dataIn.connectTo(connection);\n            }\n        }\n        if (block instanceof FlowGraphExecutionBlock) {\n            for (const signalOut of block.signalOutputs) {\n                for (const serializedConnection of signalOut.connectedPointIds) {\n                    const connection = GetSignalInConnectionByUniqueId(blocks, serializedConnection);\n                    signalOut.connectTo(connection);\n                }\n            }\n        }\n    }\n    for (const serializedContext of serializationObject.executionContexts) {\n        ParseFlowGraphContext(serializedContext, { graph, valueParseFunction }, serializationObject.rightHanded);\n    }\n    return graph;\n}\n\n/**\n * Parses a context\n * @param serializationObject the object containing the context serialization values\n * @param options the options for parsing the context\n * @param rightHanded whether the serialized data is right handed\n * @returns\n */\nexport function ParseFlowGraphContext(serializationObject: ISerializedFlowGraphContext, options: IFlowGraphContextParseOptions, rightHanded?: boolean): FlowGraphContext {\n    const result = options.graph.createContext();\n    if (serializationObject.enableLogging) {\n        result.enableLogging = true;\n    }\n    result.treatDataAsRightHanded = rightHanded || false;\n    const valueParseFunction = options.valueParseFunction ?? defaultValueParseFunction;\n    result.uniqueId = serializationObject.uniqueId;\n    const scene = result.getScene();\n    // check if assets context is available\n    if (serializationObject._assetsContext) {\n        const ac = serializationObject._assetsContext;\n        const assetsContext: IAssetContainer = {\n            meshes: ac.meshes?.map((m: string) => scene.getMeshById(m)),\n            lights: ac.lights?.map((l: string) => scene.getLightByName(l)),\n            cameras: ac.cameras?.map((c: string) => scene.getCameraByName(c)),\n            materials: ac.materials?.map((m: string) => scene.getMaterialById(m)),\n            textures: ac.textures?.map((t: string) => scene.getTextureByName(t)),\n            animations: ac.animations?.map((a: string) => scene.animations.find((anim) => anim.name === a)),\n            skeletons: ac.skeletons?.map((s: string) => scene.getSkeletonByName(s)),\n            particleSystems: ac.particleSystems?.map((ps: string) => scene.getParticleSystemById(ps)),\n            animationGroups: ac.animationGroups?.map((ag: string) => scene.getAnimationGroupByName(ag)),\n            transformNodes: ac.transformNodes?.map((tn: string) => scene.getTransformNodeById(tn)),\n            rootNodes: [],\n            multiMaterials: [],\n            morphTargetManagers: [],\n            geometries: [],\n            actionManagers: [],\n            environmentTexture: null,\n            postProcesses: [],\n            sounds: null,\n            effectLayers: [],\n            layers: [],\n            reflectionProbes: [],\n            lensFlareSystems: [],\n            proceduralTextures: [],\n            getNodes: function (): Array<Node> {\n                throw new Error(\"Function not implemented.\");\n            },\n        };\n        result.assetsContext = assetsContext;\n    }\n    for (const key in serializationObject._userVariables) {\n        const value = valueParseFunction(key, serializationObject._userVariables, result.assetsContext, scene);\n        result.userVariables[key] = value;\n    }\n    for (const key in serializationObject._connectionValues) {\n        const value = valueParseFunction(key, serializationObject._connectionValues, result.assetsContext, scene);\n        result._setConnectionValueByKey(key, value);\n    }\n\n    return result;\n}\n\n/**\n * Parses a block from a serialization object\n * This function is async due to the factory method that is used to create the block's class. If you load the class externally use ParseBlockWithClassType\n * @param serializationObject the object to parse from\n * @param parseOptions options for parsing the block\n * @returns the parsed block\n */\nexport async function ParseBlockAsync(serializationObject: ISerializedFlowGraphBlock, parseOptions: IFlowGraphBlockParseOptions): Promise<FlowGraphBlock> {\n    const classFactory = blockFactory(serializationObject.className as FlowGraphBlockNames);\n    const classType = await classFactory();\n    return ParseFlowGraphBlockWithClassType(serializationObject, parseOptions, classType);\n}\n\n/**\n * Parses a block from a serialization object\n * @param serializationObject the object to parse from\n * @param parseOptions options for parsing the block\n * @param classType the class type of the block. This is used when the class is not loaded asynchronously\n * @returns the parsed block\n */\nexport function ParseFlowGraphBlockWithClassType(\n    serializationObject: ISerializedFlowGraphBlock,\n    parseOptions: IFlowGraphBlockParseOptions,\n    classType: typeof FlowGraphBlock\n): FlowGraphBlock {\n    const parsedConfig: any = {};\n    const valueParseFunction = parseOptions.valueParseFunction ?? defaultValueParseFunction;\n    if (serializationObject.config) {\n        for (const key in serializationObject.config) {\n            parsedConfig[key] = valueParseFunction(key, serializationObject.config, parseOptions.assetsContainer || parseOptions.scene, parseOptions.scene);\n        }\n    }\n    if (needsPathConverter(serializationObject.className)) {\n        if (!parseOptions.pathConverter) {\n            throw new Error(\"Path converter is required for this block\");\n        }\n        parsedConfig.pathConverter = parseOptions.pathConverter;\n    }\n    const obj = new classType(parsedConfig);\n    obj.uniqueId = serializationObject.uniqueId;\n    for (let i = 0; i < serializationObject.dataInputs.length; i++) {\n        const dataInput = obj.getDataInput(serializationObject.dataInputs[i].name);\n        if (dataInput) {\n            dataInput.deserialize(serializationObject.dataInputs[i]);\n        } else {\n            throw new Error(\"Could not find data input with name \" + serializationObject.dataInputs[i].name + \" in block \" + serializationObject.className);\n        }\n    }\n    for (let i = 0; i < serializationObject.dataOutputs.length; i++) {\n        const dataOutput = obj.getDataOutput(serializationObject.dataOutputs[i].name);\n        if (dataOutput) {\n            dataOutput.deserialize(serializationObject.dataOutputs[i]);\n        } else {\n            throw new Error(\"Could not find data output with name \" + serializationObject.dataOutputs[i].name + \" in block \" + serializationObject.className);\n        }\n    }\n    obj.metadata = serializationObject.metadata;\n    obj.deserialize && obj.deserialize(serializationObject);\n    return obj;\n}\n\n/**\n * Parses a connection from an object\n * @param serializationObject the object to parse from.\n * @param ownerBlock the block that owns the connection.\n * @param classType the class type of the connection.\n * @returns the parsed connection.\n */\nexport function ParseGraphConnectionWithClassType<BlockT extends FlowGraphBlock>(serializationObject: any = {}, ownerBlock: BlockT, classType: typeof FlowGraphConnection) {\n    const connection = new classType(serializationObject.name, serializationObject._connectionType, ownerBlock);\n    connection.deserialize(serializationObject);\n    return connection;\n}\n\n/**\n * Parses a data connection from a serialized object.\n * @param serializationObject the object to parse from\n * @param ownerBlock the block that owns the connection\n * @param classType the class type of the data connection\n * @returns the parsed connection\n */\nexport function ParseGraphDataConnection(serializationObject: any, ownerBlock: FlowGraphBlock, classType: typeof FlowGraphDataConnection): FlowGraphDataConnection<any> {\n    const richType = ParseRichType(serializationObject.richType);\n    const defaultValue = serializationObject.defaultValue;\n    const connection = new classType(serializationObject.name, serializationObject._connectionType, ownerBlock, richType, defaultValue, !!serializationObject._optional);\n    connection.deserialize(serializationObject);\n    return connection;\n}\n\n/**\n * Parses a rich type from a serialization object.\n * @param serializationObject a serialization object\n * @returns the parsed rich type\n */\nfunction ParseRichType(serializationObject: any): RichType<any> {\n    return new RichType(serializationObject.typeName, serializationObject.defaultValue);\n}\n"]}

package/FlowGraph/flowGraphPathConverter.d.ts

@@ -2,7 +2,7 @@ import type { FlowGraphContext } from "./flowGraphContext";
 import type { IPathToObjectConverter, IObjectInfo } from "../ObjectModel/objectModelInterfaces";
 import type { IObjectAccessor } from "./typeDefinitions";
 /**
- * @experimental
+ * @deprecated Avoid using this on the flow-graph (glTF only)
  * A path converter that converts a path on the flow graph context variables to an object accessor.
  */
 export declare class FlowGraphPathConverter implements IPathToObjectConverter<IObjectAccessor> {

package/FlowGraph/flowGraphPathConverter.js

@@ -1,5 +1,5 @@
 /**
- * @experimental
+ * @deprecated Avoid using this on the flow-graph (glTF only)
  * A path converter that converts a path on the flow graph context variables to an object accessor.
  */
 export class FlowGraphPathConverter {
@@ -23,7 +23,8 @@ export class FlowGraphPathConverter {
                 type: "object",
                 get: () => currentObject[property],
                 set: (value) => (currentObject[property] = value),
-                getObject: () => currentObject,
+                getTarget: () => currentObject,
+                getPropertyName: [() => property],
             },
         };
     }

package/FlowGraph/flowGraphPathConverter.js.map

@@ -1 +1 @@
-{"version":3,"file":"flowGraphPathConverter.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraphPathConverter.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,OAAO,sBAAsB;IAC/B,YACY,QAA0B,EAC1B,aAAqB,GAAG;QADxB,aAAQ,GAAR,QAAQ,CAAkB;QAC1B,eAAU,GAAV,UAAU,CAAc;IACjC,CAAC;IAEG,OAAO,CAAC,IAAY;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC1C,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,aAAa,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,aAAa,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5C,CAAC;QACD,OAAO;YACH,MAAM,EAAE,aAAa;YACrB,IAAI,EAAE;gBACF,IAAI,EAAE,QAAQ;gBACd,GAAG,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC;gBAClC,GAAG,EAAE,CAAC,KAAU,EAAE,EAAE,CAAC,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC;gBACtD,SAAS,EAAE,GAAG,EAAE,CAAC,aAAa;aACjC;SACJ,CAAC;IACN,CAAC;CACJ","sourcesContent":["import type { FlowGraphContext } from \"./flowGraphContext\";\r\nimport type { IPathToObjectConverter, IObjectInfo } from \"../ObjectModel/objectModelInterfaces\";\r\nimport type { IObjectAccessor } from \"./typeDefinitions\";\r\n\r\n/**\r\n * @experimental\r\n * A path converter that converts a path on the flow graph context variables to an object accessor.\r\n */\r\nexport class FlowGraphPathConverter implements IPathToObjectConverter<IObjectAccessor> {\r\n    public constructor(\r\n        private _context: FlowGraphContext,\r\n        private _separator: string = \"/\"\r\n    ) {}\r\n\r\n    public convert(path: string): IObjectInfo<IObjectAccessor> {\r\n        const parts = path.split(this._separator);\r\n        if (parts.length < 2) {\r\n            throw new Error(`Path ${path} is invalid`);\r\n        }\r\n        let currentObject = this._context.getVariable(parts[0]);\r\n        const property = parts[parts.length - 1];\r\n        for (let i = 1; i < parts.length - 1; i++) {\r\n            currentObject = currentObject[parts[i]];\r\n        }\r\n        return {\r\n            object: currentObject,\r\n            info: {\r\n                type: \"object\",\r\n                get: () => currentObject[property],\r\n                set: (value: any) => (currentObject[property] = value),\r\n                getObject: () => currentObject,\r\n            },\r\n        };\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"flowGraphPathConverter.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraphPathConverter.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,OAAO,sBAAsB;IAC/B,YACY,QAA0B,EAC1B,aAAqB,GAAG;QADxB,aAAQ,GAAR,QAAQ,CAAkB;QAC1B,eAAU,GAAV,UAAU,CAAc;IACjC,CAAC;IAEG,OAAO,CAAC,IAAY;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC1C,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,aAAa,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,aAAa,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5C,CAAC;QACD,OAAO;YACH,MAAM,EAAE,aAAa;YACrB,IAAI,EAAE;gBACF,IAAI,EAAE,QAAQ;gBACd,GAAG,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC;gBAClC,GAAG,EAAE,CAAC,KAAU,EAAE,EAAE,CAAC,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC;gBACtD,SAAS,EAAE,GAAG,EAAE,CAAC,aAAa;gBAC9B,eAAe,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC;aACpC;SACJ,CAAC;IACN,CAAC;CACJ","sourcesContent":["import type { FlowGraphContext } from \"./flowGraphContext\";\r\nimport type { IPathToObjectConverter, IObjectInfo } from \"../ObjectModel/objectModelInterfaces\";\r\nimport type { IObjectAccessor } from \"./typeDefinitions\";\r\n\r\n/**\r\n * @deprecated Avoid using this on the flow-graph (glTF only)\r\n * A path converter that converts a path on the flow graph context variables to an object accessor.\r\n */\r\nexport class FlowGraphPathConverter implements IPathToObjectConverter<IObjectAccessor> {\r\n    public constructor(\r\n        private _context: FlowGraphContext,\r\n        private _separator: string = \"/\"\r\n    ) {}\r\n\r\n    public convert(path: string): IObjectInfo<IObjectAccessor> {\r\n        const parts = path.split(this._separator);\r\n        if (parts.length < 2) {\r\n            throw new Error(`Path ${path} is invalid`);\r\n        }\r\n        let currentObject = this._context.getVariable(parts[0]);\r\n        const property = parts[parts.length - 1];\r\n        for (let i = 1; i < parts.length - 1; i++) {\r\n            currentObject = currentObject[parts[i]];\r\n        }\r\n        return {\r\n            object: currentObject,\r\n            info: {\r\n                type: \"object\",\r\n                get: () => currentObject[property],\r\n                set: (value: any) => (currentObject[property] = value),\r\n                getTarget: () => currentObject,\r\n                getPropertyName: [() => property],\r\n            },\r\n        };\r\n    }\r\n}\r\n"]}

package/FlowGraph/flowGraphPathConverterComponent.d.ts

@@ -2,7 +2,7 @@ import type { IObjectInfo, IPathToObjectConverter } from "../ObjectModel/objectM
 import type { FlowGraphBlock } from "./flowGraphBlock";
 import type { FlowGraphContext } from "./flowGraphContext";
 import type { FlowGraphDataConnection } from "./flowGraphDataConnection";
-import type { FlowGraphInteger } from "./flowGraphInteger";
+import { FlowGraphInteger } from "./CustomTypes/flowGraphInteger";
 import type { IObjectAccessor } from "./typeDefinitions";
 /**
  * @experimental
@@ -16,5 +16,12 @@ export declare class FlowGraphPathConverterComponent {
      */
     readonly templatedInputs: FlowGraphDataConnection<FlowGraphInteger>[];
     constructor(path: string, ownerBlock: FlowGraphBlock);
+    /**
+     * Get the accessor for the path.
+     * @param pathConverter the path converter to use to convert the path to an object accessor.
+     * @param context the context to use.
+     * @returns the accessor for the path.
+     * @throws if the value for a templated input is invalid.
+     */
     getAccessor(pathConverter: IPathToObjectConverter<IObjectAccessor>, context: FlowGraphContext): IObjectInfo<IObjectAccessor>;
 }