@lowdefy/build 4.6.0 → 4.7.1

package/dist/build/jit/buildPageJit.js

@@ -16,24 +16,49 @@
 import path from 'path';
 import { serializer, type } from '@lowdefy/helpers';
 import { ConfigError, LowdefyInternalError } from '@lowdefy/errors';
+import operators from '@lowdefy/operators-js/operators/build';
 import addKeys from '../addKeys.js';
 import buildPage from '../buildPages/buildPage.js';
 import validateLinkReferences from '../buildPages/validateLinkReferences.js';
 import validatePayloadReferences from '../buildPages/validatePayloadReferences.js';
 import validateServerStateReferences from '../buildPages/validateServerStateReferences.js';
 import validateStateReferences from '../buildPages/validateStateReferences.js';
+import collectDynamicIdentifiers from '../collectDynamicIdentifiers.js';
 import createCheckDuplicateId from '../../utils/createCheckDuplicateId.js';
 import createContext from '../../createContext.js';
-import createRefReviver from '../buildRefs/createRefReviver.js';
-import evaluateBuildOperators from '../buildRefs/evaluateBuildOperators.js';
 import evaluateStaticOperators from '../buildRefs/evaluateStaticOperators.js';
+import getRefContent from '../buildRefs/getRefContent.js';
 import jsMapParser from '../buildJs/jsMapParser.js';
 import makeRefDefinition from '../buildRefs/makeRefDefinition.js';
-import recursiveBuild from '../buildRefs/recursiveBuild.js';
+import { resolve, WalkContext, cloneForResolve, tagRefDeep } from '../buildRefs/walker.js';
+import validateOperatorsDynamic from '../validateOperatorsDynamic.js';
+import writeMaps from '../writeMaps.js';
+import detectMissingIcons from './detectMissingIcons.js';
 import detectMissingPluginPackages from './detectMissingPluginPackages.js';
+import updateIconImportsJit from './updateIconImportsJit.js';
 import updateServerPackageJsonJit from './updateServerPackageJsonJit.js';
 import validatePageTypes from './validatePageTypes.js';
 import writePageJit from './writePageJit.js';
+validateOperatorsDynamic({
+    operators
+});
+const dynamicIdentifiers = collectDynamicIdentifiers({
+    operators
+});
+async function updateDynamicIcons({ page, context }) {
+    if (!context.iconImports) return;
+    const missingIcons = detectMissingIcons({
+        page,
+        iconImports: context.iconImports
+    });
+    if (missingIcons.length > 0) {
+        await updateIconImportsJit({
+            newIcons: missingIcons,
+            iconImports: context.iconImports,
+            context
+        });
+    }
+}
 async function buildPageJit({ pageId, pageRegistry, context, directories, logger }) {
     // Use provided context or create a minimal one for JIT builds
     const buildContext = context ?? createContext({
@@ -59,7 +84,12 @@ async function buildPageJit({ pageId, pageRegistry, context, directories, logger
             const pagePath = path.join(buildContext.directories.build, 'pages', pageId, `${pageId}.json`);
             try {
                 const content = await fs.promises.readFile(pagePath, 'utf8');
-                return serializer.deserialize(JSON.parse(content));
+                const page = serializer.deserialize(JSON.parse(content));
+                await updateDynamicIcons({
+                    page,
+                    context: buildContext
+                });
+                return page;
             } catch (err) {
                 if (err.code !== 'ENOENT') throw err;
             }
@@ -76,18 +106,20 @@ async function buildPageJit({ pageId, pageRegistry, context, directories, logger
         let resolvedVars = null;
         if (unresolvedVars) {
             const varRefDef = makeRefDefinition({}, null, buildContext.refMap);
-            resolvedVars = await recursiveBuild({
-                context: buildContext,
-                refDef: varRefDef,
-                count: 0,
-                content: unresolvedVars,
-                referencedFrom: pageEntry.refPath ?? pageEntry.resolverOriginal?.resolver
-            });
-            resolvedVars = await evaluateBuildOperators({
-                context: buildContext,
-                input: resolvedVars,
-                refDef: varRefDef
+            const varCtx = new WalkContext({
+                buildContext,
+                refId: varRefDef.id,
+                sourceRefId: null,
+                vars: {},
+                path: '',
+                currentFile: pageEntry.refPath ?? pageEntry.resolverOriginal?.resolver ?? '',
+                refChain: new Set(),
+                operators,
+                env: process.env,
+                dynamicIdentifiers,
+                shouldStop: null
             });
+            resolvedVars = await resolve(cloneForResolve(unresolvedVars), varCtx);
         }
         let refDef;
         if (pageEntry.resolverOriginal) {
@@ -105,17 +137,25 @@ async function buildPageJit({ pageId, pageRegistry, context, directories, logger
             refDef = makeRefDefinition(refDefinition, null, buildContext.refMap);
             buildContext.refMap[refDef.id].path = refDef.path;
         }
-        let processed = await recursiveBuild({
+        const pageContent = await getRefContent({
             context: buildContext,
             refDef,
-            count: 0
+            referencedFrom: null
         });
-        // Top-level operator evaluation (same as buildRefs does after recursiveBuild)
-        processed = await evaluateBuildOperators({
-            context: buildContext,
-            input: processed,
-            refDef
+        const pageCtx = new WalkContext({
+            buildContext,
+            refId: refDef.id,
+            sourceRefId: null,
+            vars: refDef.vars ?? {},
+            path: '',
+            currentFile: refDef.path ?? '',
+            refChain: new Set(),
+            operators,
+            env: process.env,
+            dynamicIdentifiers,
+            shouldStop: null
         });
+        let processed = await resolve(pageContent, pageCtx);
         processed = evaluateStaticOperators({
             context: buildContext,
             input: processed,
@@ -129,14 +169,9 @@ async function buildPageJit({ pageId, pageRegistry, context, directories, logger
                 throw new ConfigError(`Page "${pageId}" not found in resolved page source file.`);
             }
         }
-        // Stamp root-level content with ~r for correct error file tracing.
-        // recursiveBuild stamps child _ref content via createRefReviver, but the
-        // root file's own objects have no parent to do this. Without ~r, addKeys
-        // can't link objects to their source file and errors fall back to lowdefy.yaml.
-        const reviver = createRefReviver(refDef.id);
-        processed = serializer.copy(processed, {
-            reviver
-        });
+        // Tag all objects with ~r for ref provenance (normally done inside _ref
+        // resolution by the walker; JIT resolves the page file directly).
+        tagRefDeep(processed, refDef.id);
         // Apply skeleton-computed auth (buildAuth ran during skeleton build)
         processed.auth = pageEntry.auth;
         // Add keys to the resolved page
@@ -144,6 +179,11 @@ async function buildPageJit({ pageId, pageRegistry, context, directories, logger
             components: processed,
             context: buildContext
         });
+        // Write keyMap/refMap so the error handler reads JIT entries from disk.
+        // JIT addKeys assigns fresh ~k values that aren't in the skeleton keyMap.
+        await writeMaps({
+            context: buildContext
+        });
         // Initialize linkActionRefs for buildPage (normally done by buildPages)
         if (!buildContext.linkActionRefs) {
             buildContext.linkActionRefs = [];
@@ -181,6 +221,13 @@ async function buildPageJit({ pageId, pageRegistry, context, directories, logger
                 ]
             };
         }
+        // Detect icons in the JIT-resolved page that weren't discovered during skeleton build.
+        // Placed after detectMissingPluginPackages so we skip this when packages are being
+        // installed (the server restarts and icons will be discovered on the next build).
+        await updateDynamicIcons({
+            page: processed,
+            context: buildContext
+        });
         // Validate link, state, payload, and server-state references
         const pageIds = Object.keys(pageRegistry);
         validateLinkReferences({

package/dist/build/jit/createPageRegistry.js

@@ -66,10 +66,15 @@ function createPageRegistry({ components, context }) {
         const keyMapEntry = context.keyMap[page['~k']];
         const refId = keyMapEntry?.['~r'] ?? null;
         const sourceRef = !type.isNone(refId) ? findPageSourceRef(refId, context.refMap, unresolvedRefVars) : null;
+        // Inline pages (defined directly in lowdefy.yaml) have a refId pointing to
+        // the root ref but findPageSourceRef returns null because there is no
+        // separate source file. Set refId to null so buildPageJit serves them from
+        // the pre-built artifact written by buildShallowPages.
+        const isInline = !type.isNone(refId) && sourceRef === null && !type.isNone(context.refMap[refId]) && type.isNone(context.refMap[refId].parent);
         registry.set(page.id, {
             pageId: page.id,
             auth: page.auth,
-            refId,
+            refId: isInline ? null : refId,
             refPath: sourceRef?.path ?? null,
             unresolvedVars: sourceRef?.unresolvedVars ?? null,
             resolverOriginal: sourceRef?.original ?? null

package/dist/build/jit/detectMissingIcons.js

@@ -0,0 +1,36 @@
+/*
+  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 iconPackages from '../buildImports/iconPackages.js';
+function detectMissingIcons({ page, iconImports }) {
+    const pageJson = JSON.stringify(page);
+    const newIcons = [];
+    for (const [iconPackage, regex] of Object.entries(iconPackages)){
+        const existing = iconImports.find((entry)=>entry.package === iconPackage);
+        const existingSet = new Set(existing?.icons ?? []);
+        const seen = new Set();
+        for (const match of pageJson.matchAll(regex)){
+            const iconName = match[1];
+            if (!existingSet.has(iconName) && !seen.has(iconName)) {
+                seen.add(iconName);
+                newIcons.push({
+                    icon: iconName,
+                    package: iconPackage
+                });
+            }
+        }
+    }
+    return newIcons;
+}
+export default detectMissingIcons;

package/dist/build/jit/extractIconData.js

@@ -0,0 +1,54 @@
+/*
+  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 { createRequire } from 'module';
+import path from 'path';
+// Matches the JSON data argument inside GenIcon({...})(props) in react-icons source.
+// react-icons icons are generated functions of the form:
+//   function IconName(props) { return GenIcon({...})(props); }
+// Tolerates optional whitespace around GenIcon call and props argument.
+const genIconDataRegex = /GenIcon\s*\(([\s\S]*?)\)\s*\(\s*props\s*\)/;
+function extractIconData({ icons, directories, logger }) {
+    const serverRequire = createRequire(path.join(directories.server, 'package.json'));
+    const iconDataMap = {};
+    const moduleCache = {};
+    for (const { icon, package: pkg } of icons){
+        if (!moduleCache[pkg]) {
+            try {
+                moduleCache[pkg] = serverRequire(pkg);
+            } catch  {
+                if (logger) {
+                    logger.warn(`Could not load icon package "${pkg}" for dynamic icon extraction.`);
+                }
+                continue;
+            }
+        }
+        const iconFn = moduleCache[pkg][icon];
+        if (!iconFn) continue;
+        const match = iconFn.toString().match(genIconDataRegex);
+        if (match) {
+            try {
+                iconDataMap[icon] = JSON.parse(match[1]);
+            } catch  {
+                if (logger) {
+                    logger.warn(`Could not parse icon data for "${icon}" from "${pkg}".`);
+                }
+            }
+        } else if (logger) {
+            logger.warn(`Could not extract icon data for "${icon}" from "${pkg}". The icon will show as a fallback.`);
+        }
+    }
+    return iconDataMap;
+}
+export default extractIconData;

package/dist/build/jit/shallowBuild.js

@@ -48,7 +48,6 @@ import writePluginImports from '../writePluginImports/writePluginImports.js';
 import addInstalledTypes from './addInstalledTypes.js';
 import buildJsShallow from './buildJsShallow.js';
 import buildShallowPages from './buildShallowPages.js';
-import stripPageContent from './stripPageContent.js';
 import writeSourcelessPages from './writeSourcelessPages.js';
 async function shallowBuild(options) {
     makeId.reset();
@@ -73,9 +72,6 @@ async function shallowBuild(options) {
             components,
             context
         });
-        stripPageContent({
-            components
-        });
         tryBuildStep(testSchema, 'testSchema', {
             components,
             context
@@ -201,6 +197,7 @@ async function shallowBuild(options) {
             context
         });
         await context.writeBuildArtifact('jsMap.json', JSON.stringify(context.jsMap));
+        await context.writeBuildArtifact('idCounter.json', JSON.stringify(makeId.counter));
         await context.writeBuildArtifact('customTypesMap.json', JSON.stringify(options.customTypesMap ?? {}));
         // Persist snapshot of installed packages for JIT missing-package detection.
         // Written as a build artifact so JIT builds compare against the skeleton
@@ -212,6 +209,10 @@ async function shallowBuild(options) {
             components,
             context
         });
+        // Persist icon imports snapshot for JIT icon detection.
+        // When buildPageJit resolves a page, it compares discovered icons against
+        // this snapshot and regenerates plugins/icons.js if new icons are found.
+        await context.writeBuildArtifact('iconImports.json', JSON.stringify(components.imports.icons));
         await writePageRegistry({
             pageRegistry,
             context

package/dist/build/jit/updateIconImportsJit.js

@@ -0,0 +1,45 @@
+/*
+  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 extractIconData from './extractIconData.js';
+import writeIconsDynamic from './writeIconsDynamic.js';
+async function updateIconImportsJit({ newIcons, iconImports, context }) {
+    for (const { icon, package: pkg } of newIcons){
+        let entry = iconImports.find((e)=>e.package === pkg);
+        if (!entry) {
+            entry = {
+                icons: [],
+                package: pkg
+            };
+            iconImports.push(entry);
+        }
+        // Guard against concurrent JIT builds adding the same icon
+        if (!entry.icons.includes(icon)) {
+            entry.icons.push(icon);
+        }
+    }
+    await context.writeBuildArtifact('iconImports.json', JSON.stringify(iconImports));
+    // Extract SVG tree data from react-icons and write a self-contained JS module
+    // that the client can fetch at runtime without a Next.js rebuild.
+    const newIconData = extractIconData({
+        icons: newIcons,
+        directories: context.directories,
+        logger: context.logger
+    });
+    await writeIconsDynamic({
+        newIconData,
+        context
+    });
+}
+export default updateIconImportsJit;

package/dist/build/jit/{stripPageContent.js → writeIconsDynamic.js}

@@ -12,12 +12,9 @@
   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 PAGE_CONTENT_KEYS from './pageContentKeys.js';
-function stripPageContent({ components }) {
-    for (const page of components.pages ?? []){
-        for (const key of PAGE_CONTENT_KEYS){
-            delete page[key];
-        }
-    }
+*/ async function writeIconsDynamic({ newIconData, context }) {
+    Object.assign(context.dynamicIconData, newIconData);
+    const content = `export default ${JSON.stringify(context.dynamicIconData)};\n`;
+    await context.writeBuildArtifact('plugins/iconsDynamic.js', content);
 }
-export default stripPageContent;
+export default writeIconsDynamic;