@lowdefy/operators 5.5.1 → 6.0.0

package/dist/evaluateOperators.js

@@ -45,7 +45,14 @@ function hasDynamicMarker(value) {
     if ((type.isArray(value) || type.isObject(value)) && value['~dyn'] === true) return true;
     return hasDynChild(value);
 }
-function evaluateOperators({ input, operators, operatorPrefix = '_', env, dynamicIdentifiers, typeNames, args }) {
+// Build-time prefixes are '_build.' and its escaped forms ('__build.', '___build.', …)
+// produced when _function re-parses its body with `_${operatorPrefix}`. Runtime
+// prefixes ('_', '__', '___', …) never match. Escape depth does not change the
+// evaluation mode: any build prefix means the author asked for build-time evaluation.
+function isBuildPrefix(operatorPrefix) {
+    return /^_+build\.$/.test(operatorPrefix);
+}
+function evaluateOperators({ input, operators, operatorPrefix = '_', env, lowdefyApp, dynamicIdentifiers, typeNames, args }) {
     if (type.isUndefined(input)) {
         return {
             output: input,
@@ -57,6 +64,7 @@ function evaluateOperators({ input, operators, operatorPrefix = '_', env, dynami
     }
     const resolvedDynamicIdentifiers = dynamicIdentifiers ?? new Set();
     const resolvedTypeNames = typeNames ?? new Set();
+    const isBuildTimePrefix = isBuildPrefix(operatorPrefix);
     const errors = [];
     const parser = {
         parse: ({ args: callArgs, input: callInput, operatorPrefix: callPrefix })=>evaluateOperators({
@@ -64,6 +72,7 @@ function evaluateOperators({ input, operators, operatorPrefix = '_', env, dynami
                 operators,
                 operatorPrefix: callPrefix ?? operatorPrefix,
                 env,
+                lowdefyApp,
                 dynamicIdentifiers: resolvedDynamicIdentifiers,
                 typeNames: resolvedTypeNames,
                 args: callArgs
@@ -100,7 +109,7 @@ function evaluateOperators({ input, operators, operatorPrefix = '_', env, dynami
         }
         // Bubble up ~dyn from children (but not at type boundaries).
         // _build.* operators always evaluate even with dynamic params, so skip bubble-up for them.
-        const isBuildOperator = isOperatorObject && operatorPrefix === '_build.';
+        const isBuildOperator = isOperatorObject && isBuildTimePrefix;
         if (!isTypeBoundary && !isBuildOperator && hasDynamicMarker(node)) {
             return setDynamicMarker(node);
         }
@@ -111,17 +120,32 @@ function evaluateOperators({ input, operators, operatorPrefix = '_', env, dynami
         const [op, methodName] = `_${key.substring(operatorPrefix.length)}`.split('.');
         // Dynamic identifier check — skip for _build.* operators
         const fullIdentifier = methodName ? `${op}.${methodName}` : op;
-        if (operatorPrefix !== '_build.') {
+        if (!isBuildTimePrefix) {
             if (resolvedDynamicIdentifiers.has(fullIdentifier) || resolvedDynamicIdentifiers.has(op)) {
                 return setDynamicMarker(node);
             }
         }
-        // Unknown operator — mark as dynamic
+        // Unknown operator. Under a runtime prefix an operator may be runtime-only,
+        // so it is deferred by marking it dynamic. Under a build prefix (at any escape
+        // depth) the author asked for build-time evaluation, so an unknown operator
+        // (typo, or a runtime-only operator misused at build time) is a config error.
         if (type.isUndefined(operators[op])) {
+            if (isBuildTimePrefix) {
+                const error = new ConfigError(`Operator "${key}" is not a valid _build operator.`, {
+                    configKey: node['~k'],
+                    received: {
+                        [key]: node[key]
+                    }
+                });
+                error.lineNumber = node['~l'];
+                error.refId = node['~r'];
+                errors.push(error);
+                return null;
+            }
             return setDynamicMarker(node);
         }
         // Dynamic params check — skip for _build.* operators (they always evaluate)
-        if (operatorPrefix !== '_build.') {
+        if (!isBuildTimePrefix) {
             if (hasDynamicMarker(node[key])) {
                 return setDynamicMarker(node);
             }
@@ -135,6 +159,7 @@ function evaluateOperators({ input, operators, operatorPrefix = '_', env, dynami
                 args,
                 arrayIndices: [],
                 env,
+                lowdefyApp,
                 methodName,
                 operators,
                 params,

package/dist/getFromObject.js

@@ -12,7 +12,7 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import { applyArrayIndices, get, serializer, type } from '@lowdefy/helpers';
+*/ import { ReservedKeyError, applyArrayIndices, get, serializer, type } from '@lowdefy/helpers';
 function getFromObject({ params, object, arrayIndices, operator, location }) {
     if (params === true) params = {
         all: true
@@ -23,20 +23,26 @@ function getFromObject({ params, object, arrayIndices, operator, location }) {
     if (!type.isObject(params)) {
         throw new Error(`${operator} params must be of type string, integer, boolean or object.`);
     }
-    if (params.key === null) return get(params, 'default', {
+    const defaultValue = get(params, 'default', {
         default: null,
         copy: true
     });
+    if (params.key === null) return defaultValue;
     if (params.all === true) return serializer.copy(object);
     if (!type.isString(params.key) && !type.isInt(params.key)) {
         throw new Error(`${operator}.key must be of type string or integer.`);
     }
-    return get(object, applyArrayIndices(arrayIndices, params.key), {
-        default: get(params, 'default', {
-            default: null,
+    try {
+        return get(object, applyArrayIndices(arrayIndices, params.key), {
+            default: defaultValue,
             copy: true
-        }),
-        copy: true
-    });
+        });
+    } catch (error) {
+        // Tier 2: a runtime read of an app-developer keypath. There is no loud failure that helps here —
+        // a thrown error in the browser is worse than the default, and the reserved rule's job (refusing
+        // the read) is already done. Author-written identifiers fail loudly at build instead.
+        if (error instanceof ReservedKeyError) return defaultValue;
+        throw error;
+    }
 }
 export default getFromObject;

package/dist/webParser.js

@@ -71,7 +71,8 @@ let WebParser = class WebParser {
                     runtime: 'browser',
                     state: this.context.state,
                     theme,
-                    user
+                    user,
+                    websockets: this.context.websockets
                 });
                 return res;
             } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/operators",
-  "version": "5.5.1",
+  "version": "6.0.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -34,13 +34,13 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/errors": "5.5.1",
-    "@lowdefy/helpers": "5.5.1"
+    "@lowdefy/errors": "6.0.0",
+    "@lowdefy/helpers": "6.0.0"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",
-    "@swc/cli": "0.8.0",
-    "@swc/core": "1.15.18",
+    "@swc/cli": "0.8.1",
+    "@swc/core": "1.15.32",
     "@swc/jest": "0.2.39",
     "jest": "28.1.3",
     "jest-environment-jsdom": "28.1.3"