@lowdefy/build 4.7.3 → 5.0.0

package/dist/build/testSchema.js

@@ -48,9 +48,12 @@ function testSchema({ components, context }) {
                 components,
                 instancePath
             });
+            const propertyName = instancePath[instancePath.length - 1];
             let message = error.message;
             if (error.params?.additionalProperty) {
                 message = `${message} - "${error.params.additionalProperty}"`;
+            } else if (propertyName) {
+                message = `"${propertyName}" ${message}`;
             }
             const configError = new ConfigError(message, {
                 configKey,

package/dist/build/writePluginImports/collectBlockSourceContent.js

@@ -0,0 +1,65 @@
+/*
+  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 fs from 'fs';
+import path from 'path';
+import { createRequire } from 'node:module';
+// Extract all string literals from JS source that could be Tailwind class candidates.
+// We read the raw JS text — no AST parsing needed. Tailwind's scanner does the same:
+// it treats every word-like token as a potential class candidate.
+function readJsFiles(distDir) {
+    const content = [];
+    function walk(dir) {
+        for (const entry of fs.readdirSync(dir, {
+            withFileTypes: true
+        })){
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+            } else if (/\.(js|jsx|ts|tsx|mjs)$/.test(entry.name)) {
+                content.push(fs.readFileSync(fullPath, 'utf8'));
+            }
+        }
+    }
+    if (fs.existsSync(distDir)) {
+        walk(distDir);
+    }
+    return content.join('\n');
+}
+function collectBlockSourceContent({ components, serverDirectory }) {
+    // Resolve packages from the server directory, not from @lowdefy/build's own location.
+    // In production, @lowdefy/build is installed inside .lowdefy/server/node_modules/.
+    // With pnpm, import.meta.url resolves to the .pnpm store where only @lowdefy/build's
+    // own declared deps are visible. Block packages are deps of the server, not of
+    // @lowdefy/build, so require.resolve from import.meta.url silently fails.
+    // Rooting at the server's package.json ensures block packages are always reachable.
+    const requireFromServer = createRequire(path.join(serverDirectory, 'package.json'));
+    const packages = [
+        ...new Set((components.imports?.blocks ?? []).map((b)=>b.package))
+    ];
+    const allContent = [];
+    for (const packageName of packages){
+        try {
+            // Resolve the package entry to find its real location on disk.
+            // This follows pnpm symlinks, yarn PnP, npm hoisting — any install strategy.
+            const entryPath = requireFromServer.resolve(`${packageName}/blocks`);
+            const distDir = path.dirname(entryPath);
+            allContent.push(readJsFiles(distDir));
+        } catch  {
+        // Package not resolvable from server context (e.g., custom plugin not installed) — skip.
+        }
+    }
+    return allContent.join('\n');
+}
+export default collectBlockSourceContent;

package/dist/build/writePluginImports/writeActionSchemaMap.js

@@ -25,7 +25,7 @@
     for (const [packageName, actions] of Object.entries(actionsByPackage)){
         let packageSchemas;
         try {
-            packageSchemas = await import(`${packageName}/schemas`);
+            packageSchemas = await import(/* webpackIgnore: true */ `${packageName}/schemas`);
         } catch  {
         // Package not resolvable from build context (custom plugins) — skip
         }

package/dist/build/writePluginImports/writeBlockSchemaMap.js

@@ -12,8 +12,10 @@
   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.
-*/ async function writeBlockSchemaMap({ components, context }) {
+*/ import { buildBlockSchema } from '@lowdefy/block-utils';
+async function writeBlockSchemaMap({ components, context }) {
     const schemas = {};
+    const allMetas = {};
     const typesMapSchemas = context.typesMap.schemas?.blocks ?? {};
     const blocksByPackage = {};
     for (const block of components.imports.blocks){
@@ -23,20 +25,56 @@
         blocksByPackage[block.package].push(block);
     }
     for (const [packageName, blocks] of Object.entries(blocksByPackage)){
-        let packageSchemas;
+        let packageMetas;
         try {
-            packageSchemas = await import(`${packageName}/schemas`);
+            packageMetas = await import(/* webpackIgnore: true */ `${packageName}/metas`);
         } catch  {
-        // Package not resolvable from build context (custom plugins) — skip
+            try {
+                packageMetas = await import(/* webpackIgnore: true */ `${packageName}/schemas`);
+            } catch  {
+            // Package not resolvable from build context (custom plugins) — skip
+            }
         }
         for (const block of blocks){
+            const meta = packageMetas?.[block.originalTypeName];
             if (typesMapSchemas[block.typeName]) {
                 schemas[block.typeName] = typesMapSchemas[block.typeName];
-            } else if (packageSchemas?.[block.originalTypeName]) {
-                schemas[block.typeName] = packageSchemas[block.originalTypeName];
+            } else if (meta) {
+                schemas[block.typeName] = buildBlockSchema(meta);
+            }
+            if (meta) {
+                allMetas[block.typeName] = meta;
             }
         }
     }
-    return context.writeBuildArtifact('plugins/blockSchemas.json', JSON.stringify(schemas));
+    const blockMetas = {};
+    const typesMapBlockMetas = context.typesMap.blockMetas ?? {};
+    for (const block of components.imports.blocks){
+        const typesMapMeta = typesMapBlockMetas[block.typeName];
+        const meta = allMetas[block.typeName];
+        if (typesMapMeta) {
+            blockMetas[block.typeName] = {
+                category: typesMapMeta.category,
+                ...typesMapMeta.valueType != null && {
+                    valueType: typesMapMeta.valueType
+                },
+                ...typesMapMeta.initValue !== undefined && {
+                    initValue: typesMapMeta.initValue
+                }
+            };
+        } else if (meta) {
+            blockMetas[block.typeName] = {
+                category: meta.category,
+                ...meta.valueType != null && {
+                    valueType: meta.valueType
+                },
+                ...meta.initValue !== undefined && {
+                    initValue: meta.initValue
+                }
+            };
+        }
+    }
+    await context.writeBuildArtifact('plugins/blockSchemas.json', JSON.stringify(schemas));
+    await context.writeBuildArtifact('plugins/blockMetas.json', JSON.stringify(blockMetas));
 }
 export default writeBlockSchemaMap;

package/dist/build/writePluginImports/writeGlobalsCss.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 fs from 'fs';
+import path from 'path';
+import { ConfigError } from '@lowdefy/errors';
+import { mergeObjects } from '@lowdefy/helpers';
+import { writeFile } from '@lowdefy/node-utils';
+import collectBlockSourceContent from './collectBlockSourceContent.js';
+const BRIDGE_DEFAULTS = {
+    color: {
+        primary: 'var(--ant-color-primary)',
+        'primary-hover': 'var(--ant-color-primary-hover)',
+        'primary-active': 'var(--ant-color-primary-active)',
+        'primary-bg': 'var(--ant-color-primary-bg)',
+        success: 'var(--ant-color-success)',
+        warning: 'var(--ant-color-warning)',
+        error: 'var(--ant-color-error)',
+        info: 'var(--ant-color-info)',
+        'text-primary': 'var(--ant-color-text)',
+        'text-secondary': 'var(--ant-color-text-secondary)',
+        'bg-container': 'var(--ant-color-bg-container)',
+        'bg-layout': 'var(--ant-color-bg-layout)',
+        border: 'var(--ant-color-border)'
+    },
+    radius: {
+        DEFAULT: 'var(--ant-border-radius)',
+        sm: 'var(--ant-border-radius-sm)',
+        lg: 'var(--ant-border-radius-lg)'
+    },
+    'font-size': {
+        DEFAULT: 'var(--ant-font-size)',
+        sm: 'var(--ant-font-size-sm)',
+        lg: 'var(--ant-font-size-lg)'
+    },
+    'font-family': {
+        sans: 'var(--ant-font-family)'
+    }
+};
+function objectToThemeVars(obj, prefix) {
+    const lines = [];
+    for (const [key, value] of Object.entries(obj)){
+        const varName = prefix ? `${prefix}-${key}` : `--${key}`;
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            lines.push(...objectToThemeVars(value, varName));
+        } else {
+            lines.push(`  ${varName}: ${value};`);
+        }
+    }
+    return lines;
+}
+function buildThemeVars(tailwindConfig) {
+    const merged = mergeObjects([
+        {},
+        BRIDGE_DEFAULTS,
+        tailwindConfig ?? {}
+    ]);
+    return objectToThemeVars(merged).join('\n');
+}
+async function writeGlobalsCss({ components, context }) {
+    if (fs.existsSync(path.join(context.directories.config, 'public/styles.less'))) {
+        throw new ConfigError('public/styles.less is deprecated. Migrate to: (1) "theme" key in lowdefy.yaml for token overrides (recommended), (2) public/styles.css for custom CSS.');
+    }
+    const tailwindConfig = components.theme?.tailwind;
+    const themeVars = buildThemeVars(tailwindConfig);
+    const userStylesAbsolute = path.join(context.directories.config, 'public/styles.css');
+    const importUserStyles = fs.existsSync(userStylesAbsolute);
+    let userStylesImport = '';
+    if (importUserStyles) {
+        const relPath = path.relative(context.directories.build, userStylesAbsolute).split(path.sep).join('/');
+        userStylesImport = `/* User custom styles */\n@import "${relPath}" layer(components);\n\n`;
+    }
+    const css = `/* Generated by Lowdefy build */
+
+/* Layer order — locks cascade priority before Tailwind declares its own layers */
+@layer theme, base, antd, components, utilities;
+
+@import "tailwindcss";
+@import "@lowdefy/layout/grid.css";
+
+${userStylesImport}/* Content sources for Tailwind JIT — block JS content collected at build time */
+@source "../lowdefy-build/tailwind/*.html";
+
+/* Imported CSS file — when this changes, PostCSS re-runs and Tailwind re-scans @source */
+@import "./tailwind-candidates.css";
+
+/* Antd-to-Tailwind theme bridge — extends default Tailwind theme with antd design tokens */
+@theme inline {
+${themeVars}
+}
+`;
+    await context.writeBuildArtifact('globals.css', css);
+    // Standalone layer order declaration — imported FIRST in _app.js so that
+    // Next.js/Turbopack generates a critical CSS chunk that loads before any
+    // JavaScript (including antd's CSS-in-JS). This guarantees the cascade
+    // layer priority is locked (antd > base/preflight) before antd injects
+    // @layer antd {} at runtime. Without this, antd wins the race and becomes
+    // the lowest-priority layer.
+    await context.writeBuildArtifact('layer-order.css', '/* Generated by Lowdefy build */\n@layer theme, base, antd, components, utilities;\n');
+    await context.writeBuildArtifact('tailwind-candidates.css', '/* Generated by Lowdefy build — rewritten on page changes to trigger CSS recompilation */\n');
+    for (const [pageId, content] of context.tailwindContentMap ?? []){
+        await writeFile(path.join(context.directories.server, 'lowdefy-build', 'tailwind', `${pageId}.html`), '<!-- Generated by Lowdefy build -->\n' + content);
+    }
+    // Collect Tailwind class candidates from block plugin JS source files.
+    // Resolves from the server directory so block packages are reachable regardless
+    // of package manager (pnpm strict isolation, yarn PnP, npm hoisting).
+    const blockContent = collectBlockSourceContent({
+        components,
+        serverDirectory: context.directories.server
+    });
+    if (blockContent) {
+        await writeFile(path.join(context.directories.server, 'lowdefy-build', 'tailwind', '_blocks.html'), '<!-- Block plugin JS content collected at build time -->\n' + blockContent);
+    }
+}
+export default writeGlobalsCss;

package/dist/build/writePluginImports/writeOperatorSchemaMap.js

@@ -32,7 +32,7 @@
     for (const [packageName, operators] of Object.entries(operatorsByPackage)){
         let packageSchemas;
         try {
-            packageSchemas = await import(`${packageName}/schemas`);
+            packageSchemas = await import(/* webpackIgnore: true */ `${packageName}/schemas`);
         } catch  {
         // Package not resolvable from build context (custom plugins) — skip
         }

package/dist/build/writePluginImports/writePluginImports.js

@@ -21,7 +21,7 @@ import writeConnectionImports from './writeConnectionImports.js';
 import writeIconImports from './writeIconImports.js';
 import writeOperatorImports from './writeOperatorImports.js';
 import writeOperatorSchemaMap from './writeOperatorSchemaMap.js';
-import writeStyleImports from './writeStyleImports.js';
+import writeGlobalsCss from './writeGlobalsCss.js';
 async function writePluginImports({ components, context }) {
     await writeActionImports({
         components,
@@ -59,9 +59,14 @@ async function writePluginImports({ components, context }) {
         components,
         context
     });
-    await writeStyleImports({
+    await writeGlobalsCss({
         components,
         context
     });
+    // Write block package names for Next.js transpilePackages (CSS imports).
+    const blockPackages = [
+        ...new Set((components.imports.blocks ?? []).map((b)=>b.package))
+    ];
+    await context.writeBuildArtifact('blockPackages.json', JSON.stringify(blockPackages));
 }
 export default writePluginImports;

package/dist/build/writeTheme.js

@@ -0,0 +1,28 @@
+/*
+  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, serializer } from '@lowdefy/helpers';
+async function writeTheme({ components, context }) {
+    if (type.isNone(components.theme)) {
+        components.theme = {};
+    }
+    if (!type.isObject(components.theme)) {
+        throw new Error('Theme is not an object.');
+    }
+    if (type.isNone(components.theme.darkMode)) {
+        components.theme.darkMode = 'system';
+    }
+    await context.writeBuildArtifact('theme.json', serializer.serializeToString(components.theme));
+}
+export default writeTheme;

package/dist/createContext.js

@@ -25,6 +25,7 @@ function createContext({ customTypesMap, directories, logger, refResolver, stage
         directories,
         errors: [],
         jsMap: {},
+        warnings: [],
         keyMap: {},
         logger,
         readConfigFile: createReadConfigFile({
@@ -60,6 +61,7 @@ function createContext({ customTypesMap, directories, logger, refResolver, stage
             directories
         })
     };
+    context.blockMetas = context.typesMap.blockMetas ?? {};
     context.handleError = createBuildHandleError({
         context
     });