@reactvision/react-viro 2.56.0 → 2.57.2

package/dist/components/Studio/domain/collisionBindingsRuntime.js

@@ -13,7 +13,7 @@ function pairCooldownKey(pairKey, functionId) {
  * Cooldown prevents per-frame spam while physics contacts overlap.
  */
 function dispatchCollisionBindingActions(params) {
-    const { selfPlacementId, otherTag, bindingsByPairKey, sceneNavigator, animations, onSceneChange, onAnimationTrigger, cooldownMs = DEFAULT_COOLDOWN_MS, lastFiredRef, } = params;
+    const { selfPlacementId, otherTag, bindingsByPairKey, sceneNavigator, animations, onSceneChange, onAnimationTrigger, cooldownMs = DEFAULT_COOLDOWN_MS, lastFiredRef, runtimeCtx, } = params;
     if (!otherTag)
         return;
     const { asset_x_id, asset_y_id } = (0, collisionPairKey_1.canonicalizeCollisionAssetIds)(selfPlacementId, otherTag);
@@ -32,13 +32,13 @@ function dispatchCollisionBindingActions(params) {
         if (now - last < cooldownMs)
             continue;
         map.set(ck, now);
-        (0, sceneNavigationHandler_1.executeFunctionWithRelations)(fn, sceneNavigator, animations, onAnimationTrigger, 0, onSceneChange);
+        (0, sceneNavigationHandler_1.executeFunctionWithRelations)(fn, sceneNavigator, animations, onAnimationTrigger, 0, onSceneChange, runtimeCtx);
     }
 }
 /**
  * Returns an onCollision handler for a given placement asset ID.
  */
-function createPlacementCollisionHandler(placementId, bindingsByPairKey, sceneNavigator, animations, lastFiredRef, onAnimationTrigger, onSceneChange) {
+function createPlacementCollisionHandler(placementId, bindingsByPairKey, sceneNavigator, animations, lastFiredRef, onAnimationTrigger, onSceneChange, runtimeCtx) {
     return (viroTag) => {
         dispatchCollisionBindingActions({
             selfPlacementId: placementId,
@@ -49,6 +49,7 @@ function createPlacementCollisionHandler(placementId, bindingsByPairKey, sceneNa
             onSceneChange,
             onAnimationTrigger,
             lastFiredRef,
+            runtimeCtx,
         });
     };
 }

package/dist/components/Studio/domain/defaultApiRequestExecutor.d.ts

@@ -0,0 +1,14 @@
+import { StudioApiRequestExecutor } from "../types";
+/**
+ * Built-in API_REQUEST transport for production Viro apps: POSTs
+ * {function_id, variables} to the scene-api-request egress proxy through the
+ * native module, authenticated with the app's RVApiKey (same credential used
+ * to fetch scenes). Hosts with their own transport (e.g. StudioGo's JWT
+ * controller) override it via runtimeCtx.
+ *
+ * Always resolves with an outcome — transport-level problems (native module
+ * missing, RVApiKey unset, proxy auth/limit errors, malformed envelope)
+ * become a NETWORK_ERROR failure so the scene routes to the failure arm
+ * instead of crashing.
+ */
+export declare const defaultApiRequestExecutor: StudioApiRequestExecutor;

package/dist/components/Studio/domain/defaultApiRequestExecutor.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultApiRequestExecutor = void 0;
+const VRTStudioModule_1 = require("../VRTStudioModule");
+/**
+ * Built-in API_REQUEST transport for production Viro apps: POSTs
+ * {function_id, variables} to the scene-api-request egress proxy through the
+ * native module, authenticated with the app's RVApiKey (same credential used
+ * to fetch scenes). Hosts with their own transport (e.g. StudioGo's JWT
+ * controller) override it via runtimeCtx.
+ *
+ * Always resolves with an outcome — transport-level problems (native module
+ * missing, RVApiKey unset, proxy auth/limit errors, malformed envelope)
+ * become a NETWORK_ERROR failure so the scene routes to the failure arm
+ * instead of crashing.
+ */
+const defaultApiRequestExecutor = async (functionId, variables) => {
+    const result = await VRTStudioModule_1.VRTStudioModule.rvStudioApiRequest(JSON.stringify({ function_id: functionId, variables }));
+    if (!result.success || typeof result.data !== "string") {
+        return failureOutcome(extractErrorMessage(result.error));
+    }
+    try {
+        const envelope = JSON.parse(result.data);
+        return {
+            ok: envelope.ok === true,
+            status: typeof envelope.status === "number" ? envelope.status : null,
+            body: envelope.body,
+            error_code: envelope.error_code ?? null,
+            error_message: envelope.error_message ?? null,
+        };
+    }
+    catch {
+        return failureOutcome("Malformed scene-api-request response");
+    }
+};
+exports.defaultApiRequestExecutor = defaultApiRequestExecutor;
+function failureOutcome(message) {
+    return {
+        ok: false,
+        status: null,
+        error_code: "NETWORK_ERROR",
+        error_message: message,
+    };
+}
+/** Proxy auth/contract errors arrive as {"error":{"code","message"}} JSON. */
+function extractErrorMessage(error) {
+    if (!error)
+        return "Request failed";
+    try {
+        const parsed = JSON.parse(error);
+        if (typeof parsed.error?.message === "string")
+            return parsed.error.message;
+    }
+    catch {
+        // not JSON — use the raw transport error
+    }
+    return error;
+}

package/dist/components/Studio/domain/expressionEvaluator.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Studio expression evaluator: parses and evaluates the literal-or-expression
+ * values written by SET_VARIABLE steps (and, later, reused by Branch
+ * conditions via compare()). Hand-rolled tokenizer + recursive descent over a
+ * fixed grammar — never eval()/Function().
+ *
+ * Dual-maintained: this file exists in the Viro repo
+ * (components/Studio/domain/) and the ReactVisionStudio monorepo
+ * (packages/common/scene-assets/). Keep the two copies identical.
+ *
+ * Grammar (precedence low → high):
+ *   or         := and ( "||" and )*                          Boolean operands
+ *   and        := equality ( "&&" equality )*                Boolean operands
+ *   equality   := relational ( ("=="|"!=") relational )*     same-type operands
+ *   relational := additive ( ("<"|"<="|">"|">=") additive )* Number only
+ *   additive   := multiplicative ( ("+"|"-") multiplicative )*
+ *                 "+" adds Numbers, or concatenates if either side is a String
+ *   multiplicative := unary ( ("*"|"/") unary )*             Number only
+ *   unary      := ("!"|"-") unary | primary
+ *   primary    := NUMBER | STRING | "true" | "false" | IDENT | "(" or ")"
+ */
+export type StudioVariableType = "BOOLEAN" | "NUMBER" | "STRING";
+export type StudioVariableValue = boolean | number | string;
+export declare const MAX_EXPRESSION_LENGTH = 500;
+export declare const VARIABLE_NAME_PATTERN: RegExp;
+type BinaryOp = "||" | "&&" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/";
+type UnaryOp = "!" | "-";
+export type ExpressionNode = {
+    kind: "literal";
+    value: StudioVariableValue;
+} | {
+    kind: "variable";
+    name: string;
+} | {
+    kind: "unary";
+    op: UnaryOp;
+    operand: ExpressionNode;
+} | {
+    kind: "binary";
+    op: BinaryOp;
+    left: ExpressionNode;
+    right: ExpressionNode;
+};
+export type ParseResult = {
+    ok: true;
+    ast: ExpressionNode;
+    refs: string[];
+} | {
+    ok: false;
+    error: string;
+};
+export type TypeCheckResult = {
+    ok: true;
+    type: StudioVariableType;
+} | {
+    ok: false;
+    error: string;
+};
+export type EvaluateResult = {
+    ok: true;
+    value: StudioVariableValue;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseExpression(src: string): ParseResult;
+export declare function checkTypes(node: ExpressionNode, declared: Record<string, StudioVariableType>): TypeCheckResult;
+/** Parse + type-check an expression against a target variable's type in one call. */
+export declare function validateExpressionForTarget(src: string, targetType: StudioVariableType, declared: Record<string, StudioVariableType>): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+export type ComparisonOp = "==" | "!=" | "<" | "<=" | ">" | ">=";
+/** Typed comparison shared with Branch conditions. Throws on operand mismatch. */
+export declare function compare(op: ComparisonOp, left: StudioVariableValue, right: StudioVariableValue): boolean;
+export type BranchComparison = "EQUALS" | "NOT_EQUALS" | "GREATER_THAN" | "LESS_THAN" | "GREATER_OR_EQUAL" | "LESS_OR_EQUAL" | "LIKE" | "ILIKE";
+/** Structural input so this file stays standalone (no scene-type imports). */
+export type BranchConditionInput = {
+    comparison: BranchComparison;
+    variable_name: string;
+    compare_literal: StudioVariableValue | null;
+    compare_variable_name: string | null;
+};
+export type BranchConditionResult = {
+    ok: true;
+    value: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Evaluates a structured Branch condition against the runtime store.
+ * Never throws; callers warn + skip both arms on { ok: false }.
+ */
+export declare function evaluateBranchCondition(cond: BranchConditionInput, get: (name: string) => StudioVariableValue | undefined): BranchConditionResult;
+export declare function evaluate(node: ExpressionNode, get: (name: string) => StudioVariableValue | undefined): EvaluateResult;
+export declare function valueMatchesType(value: StudioVariableValue, type: StudioVariableType): boolean;
+/** Serialize a literal value into expression syntax (the editor's literal mode). */
+export declare function formatLiteral(value: StudioVariableValue): string;
+/**
+ * Rewrite every reference to oldName in an expression's source, preserving all
+ * other formatting (token-span splicing). Returns the source unchanged if it
+ * does not tokenize. Powers variable rename in the editor.
+ */
+export declare function renameIdentifier(src: string, oldName: string, newName: string): string;
+export {};