@lowdefy/engine 5.5.0 → 5.6.0

package/dist/Block.js

@@ -247,6 +247,9 @@ let Block = class Block {
             if (beforeVisible !== this.visibleEval.output) {
                 repeat.value = true;
             }
+            if (this.isList() && !this.isVisible()) {
+                this.captureHiddenValue();
+            }
             if (this.visibleEval.output !== false) {
                 this.propertiesEval = this.parse(this.properties);
                 this.requiredEval = this.parse(this.required);
@@ -347,8 +350,23 @@ let Block = class Block {
                 visibleEval: this.visibleEval
             });
         });
+        _define_property(this, "captureHiddenValue", ()=>{
+            const stateValue = get(this.context.state, this.blockId);
+            if (type.isUndefined(stateValue)) return;
+            this.hiddenValue = serializer.copy(stateValue);
+        });
+        _define_property(this, "restoreHiddenValue", ()=>{
+            if (type.isUndefined(this.hiddenValue)) return;
+            if (type.isUndefined(get(this.context.state, this.blockId))) {
+                this.context._internal.State.set(this.blockId, this.hiddenValue);
+            }
+            this.hiddenValue = undefined;
+        });
         _define_property(this, "updateState", (toSet)=>{
             if (!this.isVisible()) return;
+            if (this.isList()) {
+                this.restoreHiddenValue();
+            }
             if (this.isContainer() || this.isList()) {
                 if (this.subSlots && this.subSlots.length > 0) {
                     this.loopSubSlots((subSlotsClass)=>subSlotsClass.updateState());

package/dist/State.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 { unset, get, serializer, set, swap, type } from '@lowdefy/helpers';
+*/ import { unset, get, joinPath, serializer, set, splitPath, swap, type } from '@lowdefy/helpers';
 let State = class State {
     resetState() {
         Object.keys(this.context.state).forEach((key)=>{
@@ -35,9 +35,9 @@ let State = class State {
     del(field) {
         unset(this.context.state, field);
         // remove all empty objects from state as an effect of deleted values
-        const fields = field.split('.');
+        const fields = splitPath(field);
         if (fields.length > 1) {
-            const parent = fields.slice(0, fields.length - 1).join('.');
+            const parent = joinPath(fields.slice(0, -1));
             const parentValue = get(this.context.state, parent);
             if (type.isObject(parentValue) && Object.keys(parentValue).length === 0) {
                 this.del(parent);

package/dist/actions/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';
 const getFromObject = ({ arrayIndices, location, method, object, params })=>{
     if (params === true) params = {
         all: true
@@ -23,20 +23,26 @@ const getFromObject = ({ arrayIndices, location, method, object, params })=>{
     if (!type.isObject(params)) {
         throw new Error(`Method Error: ${method} params must be of type string, integer, boolean or object at ${location}.`);
     }
-    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(`Method Error: ${method} params.key must be of type string or integer at ${location}.`);
     }
-    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/createLink.js

@@ -12,60 +12,68 @@
   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 { type, urlQuery as urlQueryFn } from '@lowdefy/helpers';
+*/ import { type } from '@lowdefy/helpers';
+import resolveTarget from './resolveTarget.js';
 function createLink({ backLink, disabledLink, lowdefy, newOriginLink, noLink, sameOriginLink }) {
     function link(props) {
         if (props.disabled === true) {
             return disabledLink(props);
         }
-        if ([
-            !props.pageId,
-            !props.back,
-            !props.home,
-            !props.href,
-            !props.url
-        ].filter((v)=>!v).length > 1) {
-            throw new Error(`Invalid Link: To avoid ambiguity, only one of 'back', 'home', 'href', 'pageId' or 'url' can be defined.`);
-        }
+        // back has no pathname to resolve and cannot carry input or urlQuery.
         if (props.back === true) {
-            // Cannot set input or urlQuery on back
             return backLink(props);
         }
-        const query = type.isNone(props.urlQuery) ? '' : `${urlQueryFn.stringify(props.urlQuery)}`;
-        if (props.home === true) {
-            const pathname = `/${lowdefy.home.configured ? '' : lowdefy.home.pageId}`;
-            return sameOriginLink({
-                ...props,
-                pathname,
-                query,
-                setInput: ()=>{
-                    lowdefy.inputs[`page:${lowdefy.home.pageId}`] = props.input ?? {};
-                }
-            });
-        }
-        if (type.isString(props.pageId)) {
-            return sameOriginLink({
-                ...props,
-                pathname: `/${props.pageId}`,
-                query,
-                setInput: ()=>{
-                    lowdefy.inputs[`page:${props.pageId}`] = props.input ?? {};
-                }
-            });
-        }
+        // href is an HTML-attribute passthrough the <Link> component reads, not a
+        // navigation target, so it never enters the grammar resolver.
         if (type.isString(props.href)) {
             return newOriginLink(props);
         }
-        if (type.isString(props.url)) {
-            const protocol = props.url.includes(':') ? '' : 'https://';
+        const target = resolveTarget({
+            lowdefy,
+            target: {
+                home: props.home,
+                pageId: props.pageId,
+                url: props.url,
+                urlQuery: props.urlQuery
+            }
+        });
+        if (type.isNone(target)) {
+            return noLink(props);
+        }
+        if (target.kind === 'external') {
+            // The resolver's href is the whole URL with any query already folded in,
+            // so it is passed as the url prop the callback reads with an empty query.
             return newOriginLink({
                 ...props,
-                url: `${protocol}${props.url}`,
-                query
+                url: target.href,
+                query: ''
             });
         }
-        return noLink(props);
+        return sameOriginLink({
+            ...props,
+            pathname: target.pathname,
+            query: target.query,
+            setInput: getSetInput({
+                lowdefy,
+                props
+            })
+        });
     }
     return link;
 }
+// A page-kind url names no page, so it seeds no input - writing
+// inputs['page:undefined'] is the bug family a no-op setInput avoids.
+function getSetInput({ lowdefy, props }) {
+    if (props.home === true) {
+        return ()=>{
+            lowdefy.inputs[`page:${lowdefy.home.pageId}`] = props.input ?? {};
+        };
+    }
+    if (type.isString(props.pageId)) {
+        return ()=>{
+            lowdefy.inputs[`page:${props.pageId}`] = props.input ?? {};
+        };
+    }
+    return ()=>{};
+}
 export default createLink;

package/dist/getHomePathname.js

@@ -0,0 +1,34 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  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 { type } from '@lowdefy/helpers';
+// The single reading of `lowdefy.home` for every 'home' target - the Link
+// grammar in createLink and the post-auth callbackUrl ladder in the client both
+// resolve through here. Returns undefined when the app names no home page:
+// getHomeAndMenus resolves pageId to null for an app with no homePageId whose
+// authorized menu yields no link, and each caller decides what no-home means
+// for it (an invalid link, no callback target) rather than interpolating the
+// missing value into a path.
+function getHomePathname({ lowdefy }) {
+    // A configured homePageId is served at the app root - the server resolves `/`
+    // to that page, so the pageId is deliberately not in the path.
+    if (lowdefy.home?.configured === true) {
+        return '/';
+    }
+    if (type.isString(lowdefy.home?.pageId)) {
+        return `/${lowdefy.home.pageId}`;
+    }
+    return undefined;
+}
+export default getHomePathname;

package/dist/index.js

@@ -17,7 +17,9 @@ import Slots from './Slots.js';
 import createLink from './createLink.js';
 import Events from './Events.js';
 import getContext from './getContext.js';
+import getHomePathname from './getHomePathname.js';
 import Requests from './Requests.js';
+import resolveTarget from './resolveTarget.js';
 import State from './State.js';
-export { Actions, Slots, createLink, Events, Requests, State };
+export { Actions, Slots, createLink, Events, getHomePathname, Requests, resolveTarget, State };
 export default getContext;

package/dist/resolveTarget.js

@@ -0,0 +1,126 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  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 { type, urlQuery as urlQueryFn } from '@lowdefy/helpers';
+import getHomePathname from './getHomePathname.js';
+// Classifies a `url` grammar value into a page or external target. basePath is
+// stripped here, never applied - the single application boundary is createUrl.
+function classifyUrl({ lowdefy, url, query }) {
+    // The leading-slash test runs before the colon-less test: `/2fa` is an
+    // app-relative page and colon-less, and the colon-less branch would wrongly
+    // give it an `https://` scheme and parse it as an off-app origin.
+    if (url.startsWith('/')) {
+        const questionMark = url.indexOf('?');
+        const pathname = questionMark === -1 ? url : url.slice(0, questionMark);
+        const ownQuery = questionMark === -1 ? '' : url.slice(questionMark + 1);
+        // The target's own urlQuery combines with any query the string carries,
+        // matching the grammar semantics createLink resolves today.
+        const combined = [
+            ownQuery,
+            query
+        ].filter((part)=>part !== '').join('&');
+        return {
+            kind: 'page',
+            pathname,
+            query: combined
+        };
+    }
+    // A colon-less value like `example.com` is a schemeless hostname, not a path -
+    // prepend `https://` so the URL parser reads it as an absolute URL rather than
+    // the app-relative path `/example.com`. Confined to here by the leading-slash
+    // test above, so a colon-bearing path like `/path:1` never reaches it.
+    const value = url.includes(':') ? url : `https://${url}`;
+    const origin = lowdefy._internal?.globals?.window?.location?.origin;
+    // No window (SSR, tests): a `url` that reaches origin classification cannot be
+    // placed, so it resolves to nothing rather than dereferencing a missing window.
+    if (type.isNone(origin)) {
+        return undefined;
+    }
+    const parsed = new URL(value, origin);
+    const basePath = lowdefy.basePath ?? '';
+    if (parsed.origin === origin) {
+        const insideBasePath = basePath === '' || parsed.pathname.startsWith(basePath);
+        if (insideBasePath) {
+            // Strip basePath so the router does not re-apply it: an absolute
+            // `https://myapp.com/app/reports` under basePath `/app` already carries the
+            // prefix, and without stripping router.push would push `/app/app/reports`.
+            const pathname = parsed.pathname.startsWith(basePath) ? parsed.pathname.slice(basePath.length) : parsed.pathname;
+            return {
+                kind: 'page',
+                pathname,
+                query: parsed.search.replace(/^\?/, '')
+            };
+        }
+        // Same origin but outside basePath (a marketing page at the origin root while
+        // the app lives at `/app`) is a whole URL - routing it would 404 in `/app`.
+        return {
+            kind: 'external',
+            href: parsed.href
+        };
+    }
+    return {
+        kind: 'external',
+        href: parsed.href
+    };
+}
+// The single resolver of the navigation grammar { home, pageId, url, urlQuery }
+// for every reader. Returns a discriminated, un-prefixed target - never a string,
+// never basePath-prefixed - so the page/external distinction is data the consumer
+// reads rather than a shape it guesses from a leading slash.
+function resolveTarget({ lowdefy, target, name = 'Link' }) {
+    if (!type.isObject(target)) {
+        return undefined;
+    }
+    const { home, pageId, url, urlQuery } = target;
+    const defined = [
+        home,
+        pageId,
+        url
+    ].filter((value)=>value);
+    if (defined.length > 1) {
+        throw new Error(`Invalid ${name}: To avoid ambiguity, only one of 'home', 'pageId' or 'url' can be defined.`);
+    }
+    const query = type.isNone(urlQuery) ? '' : `${urlQueryFn.stringify(urlQuery)}`;
+    if (home === true) {
+        const pathname = getHomePathname({
+            lowdefy
+        });
+        // An app whose home config names no page has no resolvable home - propagate
+        // getHomePathname's undefined rather than building the literal "/undefined".
+        if (type.isNone(pathname)) {
+            return undefined;
+        }
+        return {
+            kind: 'page',
+            pathname,
+            query
+        };
+    }
+    if (type.isString(pageId)) {
+        return {
+            kind: 'page',
+            pathname: `/${pageId}`,
+            query
+        };
+    }
+    if (type.isString(url)) {
+        return classifyUrl({
+            lowdefy,
+            url,
+            query
+        });
+    }
+    return undefined;
+}
+export default resolveTarget;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/engine",
-  "version": "5.5.0",
+  "version": "5.6.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -30,16 +30,16 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/errors": "5.5.0",
-    "@lowdefy/helpers": "5.5.0",
-    "@lowdefy/operators": "5.5.0"
+    "@lowdefy/errors": "5.6.0",
+    "@lowdefy/helpers": "5.6.0",
+    "@lowdefy/operators": "5.6.0"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",
-    "@lowdefy/actions-core": "5.5.0",
-    "@lowdefy/build": "5.5.0",
-    "@lowdefy/operators-js": "5.5.0",
-    "@lowdefy/operators-mql": "5.5.0",
+    "@lowdefy/actions-core": "5.6.0",
+    "@lowdefy/build": "5.6.0",
+    "@lowdefy/operators-js": "5.6.0",
+    "@lowdefy/operators-mql": "5.6.0",
     "@swc/cli": "0.8.0",
     "@swc/core": "1.15.18",
     "@swc/jest": "0.2.39",