@nuraly/runtime 0.1.6 → 0.1.8

package/dist/{xml-axhHDYch.js → xml-DgLB7rE6.js}

@@ -1,7 +1,7 @@
-import { m as r } from "./CodeEditor-0GwD2UDB.js";
+import { m as r } from "./CodeEditor-Bf4L2rO_.js";
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.45.0(5e5af013f8d295555a7210df0d5f2cea0bf5dd56)
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license
  * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
  *-----------------------------------------------------------------------------*/
@@ -44,18 +44,24 @@ var g = {
   defaultToken: "",
   tokenPostfix: ".xml",
   ignoreCase: !0,
+  // Useful regular expressions
   qualifiedName: /(?:[\w\.\-]+:)?[\w\.\-]+/,
   tokenizer: {
     root: [
       [/[^<&]+/, ""],
       { include: "@whitespace" },
+      // Standard opening tag
       [/(<)(@qualifiedName)/, [{ token: "delimiter" }, { token: "tag", next: "@tag" }]],
+      // Standard closing tag
       [
         /(<\/)(@qualifiedName)(\s*)(>)/,
         [{ token: "delimiter" }, { token: "tag" }, "", { token: "delimiter" }]
       ],
+      // Meta tags - instruction
       [/(<\?)(@qualifiedName)/, [{ token: "delimiter" }, { token: "metatag", next: "@tag" }]],
+      // Meta tags - declaration
       [/(<\!)(@qualifiedName)/, [{ token: "delimiter" }, { token: "metatag", next: "@tag" }]],
+      // CDATA
       [/<\!\[CDATA\[/, { token: "delimiter.cdata", next: "@cdata" }],
       [/&\w+;/, "string.escape"]
     ],

package/dist/{yaml-fWSpoHsZ.js → yaml-DiI4HpSv.js}

@@ -1,7 +1,7 @@
-import { m as l } from "./CodeEditor-0GwD2UDB.js";
+import { m as l } from "./CodeEditor-Bf4L2rO_.js";
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.45.0(5e5af013f8d295555a7210df0d5f2cea0bf5dd56)
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license
  * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
  *-----------------------------------------------------------------------------*/
@@ -65,14 +65,18 @@ var p = {
     root: [
       { include: "@whitespace" },
       { include: "@comment" },
+      // Directive
       [/%[^ ]+.*$/, "meta.directive"],
+      // Document Markers
       [/---/, "operators.directivesEnd"],
       [/\.{3}/, "operators.documentEnd"],
+      // Block Structure Indicators
       [/[-?:](?= )/, "operators"],
       { include: "@anchor" },
       { include: "@tagHandle" },
       { include: "@flowCollections" },
       { include: "@blockStyle" },
+      // Numbers
       [/@numberInteger(?![ \t]*\S+)/, "number"],
       [/@numberFloat(?![ \t]*\S+)/, "number.float"],
       [/@numberOctal(?![ \t]*\S+)/, "number.octal"],
@@ -80,8 +84,10 @@ var p = {
       [/@numberInfinity(?![ \t]*\S+)/, "number.infinity"],
       [/@numberNaN(?![ \t]*\S+)/, "number.nan"],
       [/@numberDate(?![ \t]*\S+)/, "number.date"],
+      // Key:Value pair
       [/(".*?"|'.*?'|[^#'"]*?)([ \t]*)(:)( |$)/, ["type", "white", "operators", "white"]],
       { include: "@flowScalars" },
+      // String nodes
       [
         /.+?(?=(\s+#|$))/,
         {
@@ -92,18 +98,26 @@ var p = {
         }
       ]
     ],
+    // Flow Collection: Flow Mapping
     object: [
       { include: "@whitespace" },
       { include: "@comment" },
+      // Flow Mapping termination
       [/\}/, "@brackets", "@pop"],
+      // Flow Mapping delimiter
       [/,/, "delimiter.comma"],
+      // Flow Mapping Key:Value delimiter
       [/:(?= )/, "operators"],
+      // Flow Mapping Key:Value key
       [/(?:".*?"|'.*?'|[^,\{\[]+?)(?=: )/, "type"],
+      // Start Flow Style
       { include: "@flowCollections" },
       { include: "@flowScalars" },
+      // Scalar Data types
       { include: "@tagHandle" },
       { include: "@anchor" },
       { include: "@flowNumber" },
+      // Other value (keyword or string)
       [
         /[^\},]+/,
         {
@@ -114,16 +128,22 @@ var p = {
         }
       ]
     ],
+    // Flow Collection: Flow Sequence
     array: [
       { include: "@whitespace" },
       { include: "@comment" },
+      // Flow Sequence termination
       [/\]/, "@brackets", "@pop"],
+      // Flow Sequence delimiter
       [/,/, "delimiter.comma"],
+      // Start Flow Style
       { include: "@flowCollections" },
       { include: "@flowScalars" },
+      // Scalar Data types
       { include: "@tagHandle" },
       { include: "@anchor" },
       { include: "@flowNumber" },
+      // Other value (keyword or string)
       [
         /[^\],]+/,
         {
@@ -134,7 +154,10 @@ var p = {
         }
       ]
     ],
+    // First line of a Block Style
     multiString: [[/^( +).+$/, "string", "@multiStringContinued.$1"]],
+    // Further lines of a Block Style
+    //   Workaround for indentation detection
     multiStringContinued: [
       [
         /^( *).+$/,
@@ -147,11 +170,14 @@ var p = {
       ]
     ],
     whitespace: [[/[ \t\r\n]+/, "white"]],
+    // Only line comments
     comment: [[/#.*$/, "comment"]],
+    // Start Flow Collections
     flowCollections: [
       [/\[/, "@brackets", "@array"],
       [/\{/, "@brackets", "@object"]
     ],
+    // Start Flow Scalars (quoted strings)
     flowScalars: [
       [/"([^"\\]|\\.)*$/, "string.invalid"],
       [/'([^'\\]|\\.)*$/, "string.invalid"],
@@ -164,7 +190,9 @@ var p = {
       [/\\./, "string.escape.invalid"],
       [/"/, "string", "@pop"]
     ],
+    // Start Block Scalar
     blockStyle: [[/[>|][0-9]*[+-]?$/, "operators", "@multiString"]],
+    // Numbers in Flow Collections (terminate with ,]})
     flowNumber: [
       [/@numberInteger(?=[ \t]*[,\]\}])/, "number"],
       [/@numberFloat(?=[ \t]*[,\]\}])/, "number.float"],

package/handlers/compiler.ts

@@ -43,22 +43,131 @@
  */
 
 import { validateHandlerCode } from '../utils/handler-validator';
+import * as acorn from 'acorn';
+
+// Re-export createHandlerScope for use in handler-executor
+export { createHandlerScope } from './handler-scope';
+
+/**
+ * Node types that indicate control flow requiring explicit return.
+ */
+const CONTROL_FLOW_TYPES = new Set([
+  'IfStatement',
+  'ForStatement',
+  'ForInStatement',
+  'ForOfStatement',
+  'WhileStatement',
+  'DoWhileStatement',
+  'SwitchStatement',
+  'TryStatement',
+  'ThrowStatement',
+]);
+
+/**
+ * Analyzes code AST to determine if implicit return should be added.
+ * Uses acorn for proper JavaScript parsing.
+ *
+ * @param code - Handler code string
+ * @returns Analysis result with flags for return and control flow
+ */
+function analyzeCode(code: string): { hasTopLevelReturn: boolean; hasControlFlow: boolean; isMultiStatement: boolean } {
+  const trimmed = code.trim();
+
+  if (!trimmed) {
+    return { hasTopLevelReturn: false, hasControlFlow: false, isMultiStatement: false };
+  }
+
+  try {
+    // Parse as a script (not module) to allow return statements
+    // Wrap in function body to make it valid syntax for parsing
+    const wrappedCode = `(function() { ${trimmed} })`;
+    const ast = acorn.parse(wrappedCode, {
+      ecmaVersion: 'latest',
+      sourceType: 'script',
+    }) as any;
+
+    // Get the function body statements
+    const funcExpr = ast.body[0].expression;
+    const bodyStatements = funcExpr.body.body;
+
+    let hasTopLevelReturn = false;
+    let hasControlFlow = false;
+    const isMultiStatement = bodyStatements.length > 1;
+
+    // Check each top-level statement in the function body
+    for (const stmt of bodyStatements) {
+      if (stmt.type === 'ReturnStatement') {
+        hasTopLevelReturn = true;
+      }
+      if (CONTROL_FLOW_TYPES.has(stmt.type)) {
+        hasControlFlow = true;
+      }
+    }
+
+    return { hasTopLevelReturn, hasControlFlow, isMultiStatement };
+  } catch {
+    // If parsing fails, fall back to conservative behavior (no implicit return)
+    return { hasTopLevelReturn: true, hasControlFlow: false, isMultiStatement: false };
+  }
+}
+
+/**
+ * Checks if code needs an implicit return added.
+ * Uses AST analysis to properly detect top-level returns vs nested returns in callbacks.
+ *
+ * @param code - Handler code string
+ * @returns true if implicit return should be added
+ */
+function needsImplicitReturn(code: string): boolean {
+  const trimmed = code.trim();
+
+  // If empty, no return needed
+  if (!trimmed) return false;
+
+  const analysis = analyzeCode(trimmed);
+
+  // If has top-level return statement, don't add another
+  if (analysis.hasTopLevelReturn) return false;
+
+  // If has top-level control flow statements, require explicit return
+  if (analysis.hasControlFlow) return false;
+
+  // Multiple statements require explicit return
+  if (analysis.isMultiStatement) return false;
+
+  // Single expression - add implicit return
+  return true;
+}
+
+/**
+ * Wraps code with implicit return if needed.
+ *
+ * @param code - Handler code string
+ * @returns Code with return statement if needed
+ */
+function wrapWithImplicitReturn(code: string): string {
+  if (needsImplicitReturn(code)) {
+    const trimmed = code.trim().replace(/;$/, ''); // Remove trailing semicolon
+    return `return (${trimmed});`;
+  }
+  return code;
+}
 
 /**
  * Cache storage for compiled handler functions.
- * 
+ *
  * @description
  * Maps handler code strings to their compiled Function objects.
  * Cache is maintained for the lifetime of the application session.
- * 
+ *
  * @type {Record<string, Function>}
- * 
+ *
  * @remarks
  * - Key: Handler code string (exactly as written in component properties)
  * - Value: Compiled JavaScript function with injected parameters
  * - Thread-safe: Single-threaded JavaScript execution model
  * - Memory impact: ~1-2KB per unique handler on average
- * 
+ *
  * @private
  */
 const handlerFunctionCache: Record<string, Function> = {};
@@ -79,14 +188,14 @@ const handlerFunctionCache: Record<string, Function> = {};
  * @remarks
  * **Parameter Categories:**
  * 
- * 1. **Core Services** (Database, eventHandler, Components, Editor)
+ * 1. **Core Services** (eventHandler, Components, Editor)
  * 2. **Context Data** (Event, Item, Current, currentPlatform, Values, Apps, Vars)
  * 3. **Variable Functions** (SetVar, GetContextVar, GetVar, SetContextVar)
  * 4. **Component Functions** (GetComponent, GetComponents, AddComponent)
  * 5. **Application Functions** (UpdateApplication, Apps, applications)
  * 6. **Page Functions** (AddPage, UpdatePage, deletePage)
  * 7. **Navigation Functions** (NavigateToUrl, NavigateToHash, NavigateToPage)
- * 8. **Property Update Functions** (updateInput, updateName, updateEvent, updateStyle, updateStyleHandlers, updateInputHandlers)
+ * 8. **Property Update Functions** (updateInput, updateName, updateEvent, updateStyle, updateStyleHandlers)
  * 9. **Clipboard Functions** (CopyComponentToClipboard, PasteComponentFromClipboard, DeleteComponentAction)
  * 10. **Editor Functions** (openEditorTab, setCurrentEditorTab, TraitCompoentFromSchema)
  * 11. **Function Invocation** (InvokeFunction)
@@ -118,7 +227,6 @@ const handlerFunctionCache: Record<string, Function> = {};
  * ```
  */
 export const HANDLER_PARAMETERS = [
-  "Database",
   "eventHandler",
   "Components",
   "Editor",
@@ -146,7 +254,6 @@ export const HANDLER_PARAMETERS = [
   "context",
   "applications",
   "updateInput",
-  "updateInputHandlers",
   "deletePage",
   "CopyComponentToClipboard",
   "PasteComponentFromClipboard",
@@ -171,6 +278,15 @@ export const HANDLER_PARAMETERS = [
   "ShowInfoToast",
   "HideToast",
   "ClearAllToasts",
+  "__createScope__", // For transparent variable access
+  // Namespaced API object (new clean API)
+  "Nav",
+  "UI",
+  "Component",
+  "Data",
+  "Page",
+  "App",
+  "Var",
 ] as const;
 
 /**
@@ -254,9 +370,41 @@ export const HANDLER_PARAMETERS = [
  * @see {@link executeHandler} for the execution wrapper that calls compiled functions
  * @see {@link HANDLER_PARAMETERS} for the list of available parameters in handler code
  */
+/**
+ * Flag to enable/disable transparent variable access.
+ * When enabled, users can write `username = 'John'` instead of `$username = 'John'`.
+ *
+ * Set to false to use traditional explicit Vars access.
+ */
+let transparentVarsEnabled = true;
+
+/**
+ * Enable or disable transparent variable access in handlers.
+ *
+ * When enabled (default), variables like `username` automatically
+ * resolve to `$username` for reactive access.
+ *
+ * @param enabled - Whether to enable transparent variable access
+ */
+export function setTransparentVarsEnabled(enabled: boolean): void {
+  transparentVarsEnabled = enabled;
+  // Clear cache when mode changes to recompile handlers
+  clearHandlerCache();
+}
+
+/**
+ * Check if transparent variable access is enabled.
+ */
+export function isTransparentVarsEnabled(): boolean {
+  return transparentVarsEnabled;
+}
+
 export function compileHandlerFunction(code: string): Function {
+  // Include mode in cache key to handle mode changes
+  const cacheKey = transparentVarsEnabled ? `scope:${code}` : code;
+
   // Check cache first for performance
-  if (!handlerFunctionCache[code]) {
+  if (!handlerFunctionCache[cacheKey]) {
     // Validate handler code before compilation
     // This is a safety layer in case validation was bypassed at save time
     const validationResult = validateHandlerCode(code);
@@ -264,14 +412,46 @@ export function compileHandlerFunction(code: string): Function {
       throw new Error(`Handler validation failed: ${validationResult.errors[0]?.message || 'Unknown error'}`);
     }
 
-    // Create new Function with all runtime parameters
-    // The code is wrapped in an IIFE to provide proper scoping
-    handlerFunctionCache[code] = new Function(
-      ...HANDLER_PARAMETERS,
-      `return (function() { ${code} }).apply(this);`
-    );
+    // Wrap with implicit return if needed (e.g., "$name ?? 'hello'" becomes "return ($name ?? 'hello');")
+    const processedCode = wrapWithImplicitReturn(code);
+
+    if (transparentVarsEnabled) {
+      // Compile with transparent variable access using `with` statement
+      // The scope proxy routes unknown variables to VarsProxy
+      handlerFunctionCache[cacheKey] = new Function(
+        ...HANDLER_PARAMETERS,
+        `
+        var __scope__ = __createScope__({
+          VarsProxy: Vars,
+          parameters: {
+            eventHandler: eventHandler, Components, Editor, Event, Item,
+            Current, currentPlatform, Values, Apps, Vars, SetVar, GetContextVar,
+            UpdateApplication, GetVar, GetComponent, GetComponents, AddComponent,
+            SetContextVar, AddPage, TraitCompoentFromSchema, NavigateToUrl,
+            NavigateToHash, NavigateToPage, UpdatePage, context, applications,
+            updateInput, deletePage, CopyComponentToClipboard, PasteComponentFromClipboard,
+            DeleteComponentAction, updateName, updateEvent, updateStyleHandlers,
+            EventData, updateStyle, openEditorTab, setCurrentEditorTab, InvokeFunction,
+            Utils, console, UploadFile, BrowseFiles, Instance, ShowToast,
+            ShowSuccessToast, ShowErrorToast, ShowWarningToast, ShowInfoToast,
+            HideToast, ClearAllToasts,
+            Nav, UI, Component, Data, Page, App, Var
+          }
+        });
+        with (__scope__) {
+          return (function() { ${processedCode} }).apply(this);
+        }
+        `
+      );
+    } else {
+      // Traditional compilation without scope proxy
+      handlerFunctionCache[cacheKey] = new Function(
+        ...HANDLER_PARAMETERS,
+        `return (function() { ${processedCode} }).apply(this);`
+      );
+    }
   }
-  return handlerFunctionCache[code];
+  return handlerFunctionCache[cacheKey];
 }
 
 /**

package/handlers/context-setup.ts

@@ -229,8 +229,14 @@ export function setupRuntimeContext(context: IRuntimeContext, component: any, Ev
   context.Current.style = context.Current.style ?? {};
 
   // Create or retrieve style proxy for reactive style updates
-  if (!context.styleProxyCache.has(context.Current.style)) {
-    const newProxy = observe(context.Current.style, (target, prop, value) => {
+  // IMPORTANT: Keep reference to original style object BEFORE checking cache
+  // This fixes the issue where we were caching proxy -> proxy instead of original -> proxy
+  const originalStyle = context.Current.style;
+
+  if (context.styleProxyCache.has(originalStyle)) {
+    context.Current.style = context.styleProxyCache.get(originalStyle);
+  } else {
+    const newProxy = observe(originalStyle, (target, prop, value) => {
       context.setComponentRuntimeStyleAttribute(
         context.Current.uniqueUUID,
         prop,
@@ -238,10 +244,9 @@ export function setupRuntimeContext(context: IRuntimeContext, component: any, Ev
       );
     });
 
+    // Cache using original object as key, proxy as value
+    context.styleProxyCache.set(originalStyle, newProxy);
     context.Current.style = newProxy;
-    context.styleProxyCache.set(context.Current.style, newProxy);
-  } else {
-    context.Current.style = context.styleProxyCache.get(context.Current.style);
   }
 }