@lowdefy/build 0.0.0-experimental-20260114142524 → 0.0.0-experimental-20260122121633

package/dist/build/buildPages/buildPage.js

@@ -13,26 +13,26 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/node-utils';
 import buildBlock from './buildBlock/buildBlock.js';
 import createCheckDuplicateId from '../../utils/createCheckDuplicateId.js';
 import createCounter from '../../utils/createCounter.js';
-import formatConfigError from '../../utils/formatConfigError.js';
 import validateRequestReferences from './validateRequestReferences.js';
 function buildPage({ page, index, context, checkDuplicatePageId }) {
     const configKey = page['~k'];
     if (type.isUndefined(page.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Page id missing at page ${index}.`,
             configKey,
             context
-        }));
+        });
     }
     if (!type.isString(page.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Page id is not a string at page ${index}. Received ${JSON.stringify(page.id)}.`,
             configKey,
             context
-        }));
+        });
     }
     checkDuplicatePageId({
         id: page.id,

package/dist/build/buildPages/validateLinkReferences.js

@@ -12,21 +12,20 @@
   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 formatConfigError from '../../utils/formatConfigError.js';
-function validateLinkReferences({ linkActionRefs, pageIds, context }) {
+*/ function validateLinkReferences({ linkActionRefs, pageIds, context }) {
     const pageIdSet = new Set(pageIds);
     linkActionRefs.forEach(({ pageId, action, sourcePageId })=>{
+        // Only skip validation if skip is explicitly true
+        // Pages must exist in app even if Link is conditional
+        if (action.skip === true) {
+            return;
+        }
         if (!pageIdSet.has(pageId)) {
-            const errorMessage = formatConfigError({
+            context.logger.configWarning({
                 message: `Page "${pageId}" not found. Link on page "${sourcePageId}" references non-existent page.`,
                 configKey: action['~k'],
-                context
+                prodError: true
             });
-            if (context.stage === 'dev' || context.stage === 'test') {
-                context.logger.warn(errorMessage);
-            } else {
-                throw new Error(errorMessage);
-            }
         }
     });
 }

package/dist/build/buildPages/validatePayloadReferences.js

@@ -13,7 +13,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import extractOperatorKey from '../../utils/extractOperatorKey.js';
-import formatConfigWarning from '../../utils/formatConfigWarning.js';
 import traverseConfig from '../../utils/traverseConfig.js';
 function validatePayloadReferences({ page, context }) {
     const requests = page.requests || [];
@@ -41,11 +40,11 @@ function validatePayloadReferences({ page, context }) {
         payloadRefs.forEach((configKey, topLevelKey)=>{
             if (payloadKeys.has(topLevelKey)) return;
             const message = `_payload references "${topLevelKey}" in request "${request.requestId}" on page "${page.pageId}", ` + `but no key "${topLevelKey}" exists in the request payload definition. ` + `Payload keys are defined in the request's "payload" property. ` + `Check for typos or add the key to the payload definition.`;
-            context.logger.warn(formatConfigWarning({
+            context.logger.configWarning({
                 message,
                 configKey,
-                context
-            }));
+                prodError: true
+            });
         });
     });
 }

package/dist/build/buildPages/validateRequestReferences.js

@@ -12,21 +12,20 @@
   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 formatConfigError from '../../utils/formatConfigError.js';
+*/ import { type } from '@lowdefy/helpers';
 function validateRequestReferences({ requestActionRefs, requests, pageId, context }) {
     const requestIds = new Set(requests.map((req)=>req.requestId));
     requestActionRefs.forEach(({ requestId, action })=>{
+        // Skip validation if action has skip condition (true or operator object)
+        if (action.skip === true || type.isObject(action.skip)) {
+            return;
+        }
         if (!requestIds.has(requestId)) {
-            const errorMessage = formatConfigError({
+            context.logger.configWarning({
                 message: `Request "${requestId}" not defined on page "${pageId}".`,
                 configKey: action['~k'],
-                context
+                prodError: true
             });
-            if (context.stage === 'dev' || context.stage === 'test') {
-                context.logger.warn(errorMessage);
-            } else {
-                throw new Error(errorMessage);
-            }
         }
     });
 }

package/dist/build/buildPages/validateStateReferences.js

@@ -13,7 +13,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import extractOperatorKey from '../../utils/extractOperatorKey.js';
-import formatConfigWarning from '../../utils/formatConfigWarning.js';
 import traverseConfig from '../../utils/traverseConfig.js';
 function validateStateReferences({ page, context }) {
     // Single traversal collects blockIds, _state references, and SetState keys
@@ -51,11 +50,11 @@ function validateStateReferences({ page, context }) {
         // Skip if state key is from an input block or SetState action
         if (blockIds.has(topLevelKey) || setStateKeys.has(topLevelKey)) return;
         const message = `_state references "${topLevelKey}" on page "${page.pageId}", ` + `but no input block with id "${topLevelKey}" exists on this page. ` + `State keys are created from input block ids. ` + `Check for typos, add an input block with this id, or initialize the state with SetState.`;
-        context.logger.warn(formatConfigWarning({
+        context.logger.configWarning({
             message,
             configKey,
-            context
-        }));
+            prodError: true
+        });
     });
 }
 export default validateStateReferences;

package/dist/build/buildRefs/buildRefs.js

@@ -15,6 +15,7 @@
 */ import recursiveBuild from './recursiveBuild.js';
 import makeRefDefinition from './makeRefDefinition.js';
 import evaluateBuildOperators from './evaluateBuildOperators.js';
+import evaluateStaticOperators from './evaluateStaticOperators.js';
 async function buildRefs({ context }) {
     const refDef = makeRefDefinition('lowdefy.yaml', null, context.refMap);
     let components = await recursiveBuild({
@@ -22,11 +23,18 @@ async function buildRefs({ context }) {
         refDef,
         count: 0
     });
+    // First: evaluate _build.* operators (e.g., _build.env)
     components = await evaluateBuildOperators({
         context,
         input: components,
         refDef
     });
+    // Second: evaluate static operators (_sum, _if, etc.) that don't depend on runtime data
+    components = evaluateStaticOperators({
+        context,
+        input: components,
+        refDef
+    });
     return components ?? {};
 }
 export default buildRefs;

package/dist/build/buildRefs/evaluateBuildOperators.js

@@ -14,10 +14,20 @@
   limitations under the License.
 */ import { BuildParser } from '@lowdefy/operators';
 import operators from '@lowdefy/operators-js/operators/build';
+import collectDynamicIdentifiers from '../collectDynamicIdentifiers.js';
+import validateOperatorsDynamic from '../validateOperatorsDynamic.js';
+// Validate and collect dynamic identifiers once at module load
+validateOperatorsDynamic({
+    operators
+});
+const dynamicIdentifiers = collectDynamicIdentifiers({
+    operators
+});
 async function evaluateBuildOperators({ context, input, refDef }) {
     const operatorsParser = new BuildParser({
         env: process.env,
-        operators
+        operators,
+        dynamicIdentifiers
     });
     const { output, errors } = operatorsParser.parse({
         input,

package/dist/build/buildRefs/evaluateStaticOperators.js

@@ -0,0 +1,54 @@
+/*
+  Copyright 2020-2024 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 { BuildParser } from '@lowdefy/operators';
+import operators from '@lowdefy/operators-js/operators/build';
+import collectDynamicIdentifiers from '../collectDynamicIdentifiers.js';
+import collectTypeNames from '../collectTypeNames.js';
+import validateOperatorsDynamic from '../validateOperatorsDynamic.js';
+// Validate and collect dynamic identifiers once at module load
+validateOperatorsDynamic({
+    operators
+});
+const dynamicIdentifiers = collectDynamicIdentifiers({
+    operators
+});
+function evaluateStaticOperators({ context, input, refDef }) {
+    // Collect type names from context.typesMap for type boundary detection
+    const typeNames = collectTypeNames({
+        typesMap: context.typesMap
+    });
+    const operatorsParser = new BuildParser({
+        env: process.env,
+        operators,
+        dynamicIdentifiers,
+        typeNames
+    });
+    const location = refDef.path ?? refDef.resolver;
+    const { output, errors } = operatorsParser.parse({
+        input,
+        location,
+        operatorPrefix: '_'
+    });
+    if (errors.length > 0) {
+        errors.forEach((error)=>{
+            context.logger.configWarning({
+                message: error.message,
+                operatorLocation: error.operatorLocation
+            });
+        });
+    }
+    return output;
+}
+export default evaluateStaticOperators;

package/dist/build/buildRefs/getConfigFile.js

@@ -14,31 +14,36 @@
   limitations under the License.
 */ import path from 'path';
 import { type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/node-utils';
 async function getConfigFile({ context, refDef, referencedFrom }) {
     if (!type.isString(refDef.path)) {
-        throw new Error(`Invalid _ref definition ${JSON.stringify({
-            _ref: refDef.original
-        })} in file ${referencedFrom}`);
+        throw new ConfigError({
+            message: `Invalid _ref definition: ${JSON.stringify({
+                _ref: refDef.original
+            })}`,
+            filePath: referencedFrom,
+            lineNumber: refDef.lineNumber,
+            configDirectory: context.directories.config
+        });
     }
     const content = await context.readConfigFile(refDef.path);
     if (content === null) {
-        // Build helpful error message with resolved path information
-        const lineInfo = refDef.lineNumber ? `:${refDef.lineNumber}` : '';
         const absolutePath = path.resolve(context.directories.config, refDef.path);
-        let message = `[Config Error] Referenced file does not exist: "${refDef.path}"\n`;
-        message += `  Referenced from: ${referencedFrom}${lineInfo}\n`;
-        message += `  Resolved to: ${absolutePath}\n`;
+        let message = `Referenced file does not exist: "${refDef.path}". Resolved to: ${absolutePath}`;
         // Help with common mistakes
         if (refDef.path.startsWith('../')) {
             const suggestedPath = refDef.path.replace(/^(\.\.\/)+/, '');
-            message += `\n  Tip: Paths in _ref are resolved from your config directory root.`;
-            message += `\n  Did you mean: "${suggestedPath}"?`;
+            message += ` Tip: Paths in _ref are resolved from config root. Did you mean "${suggestedPath}"?`;
         } else if (refDef.path.startsWith('./')) {
             const suggestedPath = refDef.path.substring(2);
-            message += `\n  Tip: Remove the "./" prefix - paths are resolved from config root.`;
-            message += `\n  Did you mean: "${suggestedPath}"?`;
+            message += ` Tip: Remove "./" prefix - paths are resolved from config root. Did you mean "${suggestedPath}"?`;
         }
-        throw new Error(message);
+        throw new ConfigError({
+            message,
+            filePath: referencedFrom,
+            lineNumber: refDef.lineNumber,
+            configDirectory: context.directories.config
+        });
     }
     return content;
 }

package/dist/build/buildRefs/getRefContent.js

@@ -12,7 +12,8 @@
   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 getConfigFile from './getConfigFile.js';
+*/ import { ConfigError } from '@lowdefy/node-utils';
+import getConfigFile from './getConfigFile.js';
 import parseRefContent from './parseRefContent.js';
 import runRefResolver from './runRefResolver.js';
 async function getRefContent({ context, refDef, referencedFrom }) {
@@ -36,9 +37,18 @@ async function getRefContent({ context, refDef, referencedFrom }) {
             referencedFrom
         });
     }
-    return parseRefContent({
-        content,
-        refDef
-    });
+    try {
+        return parseRefContent({
+            content,
+            refDef
+        });
+    } catch (error) {
+        // Re-throw parse errors as ConfigError with location info
+        throw new ConfigError({
+            message: `Error parsing "${refDef.path}": ${error.message}`,
+            filePath: refDef.path,
+            configDirectory: context.directories.config
+        });
+    }
 }
 export default getRefContent;

package/dist/build/buildRefs/makeRefDefinition.js

@@ -16,7 +16,7 @@
 import getRefPath from './getRefPath.js';
 import makeId from '../../utils/makeId.js';
 function makeRefDefinition(refDefinition, parent, refMap, lineNumber) {
-    const id = makeId();
+    const id = makeId.next();
     const refDef = {
         parent,
         lineNumber

package/dist/build/buildRefs/parseRefContent.js

@@ -36,10 +36,32 @@ function addLineNumbers(node, content, result) {
             if (isPair(pair) && isScalar(pair.key)) {
                 const key = pair.key.value;
                 const value = pair.value;
+                // Use key's line number for the value's ~l (more useful for error messages)
+                const keyLineNumber = pair.key.range ? getLineNumber(content, pair.key.range[0]) : null;
                 if (isMap(value)) {
-                    obj[key] = addLineNumbers(value, content, {});
+                    const mapResult = addLineNumbers(value, content, {});
+                    // Override ~l with key's line number if available
+                    if (keyLineNumber) {
+                        Object.defineProperty(mapResult, '~l', {
+                            value: keyLineNumber,
+                            enumerable: false,
+                            writable: true,
+                            configurable: true
+                        });
+                    }
+                    obj[key] = mapResult;
                 } else if (isSeq(value)) {
-                    obj[key] = addLineNumbers(value, content, []);
+                    const arrResult = addLineNumbers(value, content, []);
+                    // Override ~l with key's line number if available
+                    if (keyLineNumber) {
+                        Object.defineProperty(arrResult, '~l', {
+                            value: keyLineNumber,
+                            enumerable: false,
+                            writable: true,
+                            configurable: true
+                        });
+                    }
+                    obj[key] = arrResult;
                 } else if (isScalar(value)) {
                     obj[key] = value.value;
                 } else {
@@ -51,6 +73,14 @@ function addLineNumbers(node, content, result) {
     }
     if (isSeq(node)) {
         const arr = result || [];
+        if (node.range) {
+            Object.defineProperty(arr, '~l', {
+                value: getLineNumber(content, node.range[0]),
+                enumerable: false,
+                writable: true,
+                configurable: true
+            });
+        }
         for (const item of node.items){
             if (isMap(item)) {
                 arr.push(addLineNumbers(item, content, {}));

package/dist/build/buildRefs/populateRefs.js

@@ -13,6 +13,40 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { get, serializer, type } from '@lowdefy/helpers';
+/**
+ * Copies a _var value while preserving source location markers.
+ *
+ * When _var copies a value from vars into a template, we need to preserve
+ * the ~r (ref ID) and ~l (line number) from WHERE THE VALUE IS DEFINED
+ * (the source file), not where _var is used (the template).
+ *
+ * The issue is that serializer.copy loses non-enumerable properties, and
+ * recursiveBuild.js then sets ~r to the template file for objects without ~r.
+ *
+ * This function preserves the source location by making ~r enumerable on
+ * the copied value, so it survives through subsequent serializer.copy calls.
+ *
+ * @param {*} value - The value to copy from vars
+ * @param {string} sourceRefId - The ref ID of the source file where the var is defined
+ * @returns {*} The copied value with preserved source location markers
+ */ function copyVarValue(value, sourceRefId) {
+    if (!type.isObject(value) && !type.isArray(value)) {
+        return value;
+    }
+    // Copy the value, preserving ~l and setting ~r to the source file
+    return serializer.copy(value, {
+        reviver: (_, v)=>{
+            if (type.isObject(v)) {
+                // Preserve the source file's ref ID by setting it explicitly
+                // This prevents recursiveBuild from overwriting it with the template's ref ID
+                if (sourceRefId && v['~r'] === undefined) {
+                    v['~r'] = sourceRefId;
+                }
+            }
+            return v;
+        }
+    });
+}
 function refReviver(key, value) {
     if (type.isObject(value)) {
         if (!type.isUndefined(value._ref)) {
@@ -20,14 +54,16 @@ function refReviver(key, value) {
         }
         if (value._var) {
             if (type.isString(value._var)) {
-                return serializer.copy(get(this.vars, value._var, {
+                const varValue = get(this.vars, value._var, {
                     default: null
-                }));
+                });
+                return copyVarValue(varValue, this.sourceRefId);
             }
             if (type.isObject(value._var) && type.isString(value._var.key)) {
-                return serializer.copy(get(this.vars, value._var.key, {
+                const varValue = get(this.vars, value._var.key, {
                     default: type.isNone(value._var.default) ? null : value._var.default
-                }));
+                });
+                return copyVarValue(varValue, this.sourceRefId);
             }
             throw new Error(`"_var" operator takes a string or object with "key" field as arguments. Received "${JSON.stringify(value)}"`);
         }
@@ -36,10 +72,12 @@ function refReviver(key, value) {
 }
 function populateRefs({ parsedFiles, refDef, toPopulate }) {
     // Use serializer.copy to preserve non-enumerable properties like ~r, ~k, ~l
+    // sourceRefId is the PARENT file's ref ID where vars are defined (not the template's ID)
     return serializer.copy(toPopulate, {
         reviver: refReviver.bind({
             parsedFiles,
-            vars: refDef.vars
+            vars: refDef.vars,
+            sourceRefId: refDef.parent
         })
     });
 }

package/dist/build/buildRefs/recursiveBuild.js

@@ -13,8 +13,8 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { serializer, type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/node-utils';
 import evaluateBuildOperators from './evaluateBuildOperators.js';
-import formatConfigError from '../../utils/formatConfigError.js';
 import getKey from './getKey.js';
 import getRefContent from './getRefContent.js';
 import getRefsFromFile from './getRefsFromFile.js';
@@ -30,20 +30,22 @@ async function recursiveBuild({ context, refDef, count, referencedFrom, refChain
                 ...refChainList,
                 currentPath
             ].join('\n  -> ');
-            throw new Error(formatConfigError({
-                message: `Circular reference detected.\nFile "${currentPath}" references itself through:\n  -> ${chainDisplay}`,
-                context
-            }));
+            throw new ConfigError({
+                message: `Circular reference detected. File "${currentPath}" references itself through:\n  -> ${chainDisplay}`,
+                filePath: referencedFrom,
+                lineNumber: refDef.lineNumber,
+                configDirectory: context.directories.config
+            });
         }
         refChainSet.add(currentPath);
         refChainList.push(currentPath);
     }
     // Keep count as a fallback safety limit
     if (count > 10000) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Maximum recursion depth of references exceeded (10000 levels). This likely indicates a circular reference.`,
             context
-        }));
+        });
     }
     let fileContent = await getRefContent({
         context,

package/dist/build/buildRefs/runRefResolver.js

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/node-utils';
 import getUserJavascriptFunction from './getUserJavascriptFunction.js';
 async function runRefResolver({ context, refDef, referencedFrom }) {
     const resolverFn = await getUserJavascriptFunction({
@@ -23,10 +24,20 @@ async function runRefResolver({ context, refDef, referencedFrom }) {
     try {
         content = await resolverFn(refDef.path, refDef.vars, context);
     } catch (error) {
-        throw new Error(`Error calling resolver "${refDef.resolver}" from "${referencedFrom}": ${error.message}`);
+        throw new ConfigError({
+            message: `Error calling resolver "${refDef.resolver}": ${error.message}`,
+            filePath: referencedFrom,
+            lineNumber: refDef.lineNumber,
+            configDirectory: context.directories.config
+        });
     }
     if (type.isNone(content)) {
-        throw new Error(`Tried to reference with resolver "${refDef.resolver}" from "${referencedFrom}", but received "${content}".`);
+        throw new ConfigError({
+            message: `Resolver "${refDef.resolver}" returned "${content}".`,
+            filePath: referencedFrom,
+            lineNumber: refDef.lineNumber,
+            configDirectory: context.directories.config
+        });
     }
     return content;
 }

package/dist/build/buildTypes.js

@@ -16,11 +16,20 @@
 import loaderTypes from '@lowdefy/blocks-loaders/types';
 import findSimilarString from '../utils/findSimilarString.js';
 import formatBuildError from './formatBuildError.js';
+// Check if a configKey has ~ignoreBuildCheck set
+function hasIgnoreBuildCheck(keyMap, configKey) {
+    return keyMap[configKey]?.['~ignoreBuildCheck'] === true;
+}
 function buildTypeClass(context, { counter, definitions, store, typeClass, warnIfMissing = false }) {
     const counts = counter.getCounts();
     const definedTypes = Object.keys(definitions);
     Object.keys(counts).forEach((typeName)=>{
         if (!definitions[typeName]) {
+            // Check if this type usage has ~ignoreBuildCheck flag
+            const configKey = counter.getLocation(typeName);
+            if (configKey && hasIgnoreBuildCheck(context.keyMap, configKey)) {
+                return; // Skip warning/error for this type
+            }
             let message = `${typeClass} type "${typeName}" was used but is not defined.`;
             const suggestion = findSimilarString({
                 input: typeName,

package/dist/build/collectDynamicIdentifiers.js

@@ -0,0 +1,35 @@
+/*
+  Copyright 2020-2024 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';
+function collectDynamicIdentifiers({ operators }) {
+    const dynamicIdentifiers = new Set();
+    Object.entries(operators).forEach(([operatorName, operatorFn])=>{
+        if (!type.isFunction(operatorFn)) return;
+        if (operatorFn.dynamic === true) {
+            dynamicIdentifiers.add(operatorName);
+            return;
+        }
+        // Check for method-level dynamic in meta
+        if (type.isObject(operatorFn.meta)) {
+            Object.entries(operatorFn.meta).forEach(([methodName, methodMeta])=>{
+                if (type.isObject(methodMeta) && methodMeta.dynamic === true) {
+                    dynamicIdentifiers.add(`${operatorName}.${methodName}`);
+                }
+            });
+        }
+    });
+    return dynamicIdentifiers;
+}
+export default collectDynamicIdentifiers;

package/dist/{utils/formatConfigError.js → build/collectTypeNames.js}

@@ -12,13 +12,25 @@
   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 formatConfigMessage from './formatConfigMessage.js';
-function formatConfigError({ message, configKey, context }) {
-    return formatConfigMessage({
-        prefix: '[Config Error]',
-        message,
-        configKey,
-        context
+*/ import { type } from '@lowdefy/helpers';
+function collectTypeNames({ typesMap }) {
+    const typeNames = new Set();
+    if (!type.isObject(typesMap)) {
+        return typeNames;
+    }
+    [
+        'blocks',
+        'requests',
+        'connections',
+        'actions',
+        'controls'
+    ].forEach((category)=>{
+        if (type.isObject(typesMap[category])) {
+            Object.keys(typesMap[category]).forEach((typeName)=>{
+                typeNames.add(typeName);
+            });
+        }
     });
+    return typeNames;
 }
-export default formatConfigError;
+export default collectTypeNames;

package/dist/build/formatBuildError.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 { resolveConfigLocation } from '@lowdefy/helpers';
+*/ import { resolveConfigLocation } from '@lowdefy/node-utils';
 function formatBuildError({ context, counter, typeName, message }) {
     const configKey = counter.getLocation(typeName);
     if (!configKey) {