@lowdefy/build 4.0.0-alpha.7 → 4.0.0-alpha.8

package/dist/build/buildIcons.js

@@ -50,8 +50,8 @@ function getConfigIcons({ components , icons , regex  }) {
     );
 }
 function getBlockDefaultIcons({ components , context , icons , regex  }) {
-    Object.entries(components.types.blocks).forEach(([blockName, block])=>{
-        context.types.icons[block.package][blockName].forEach((icon)=>{
+    Object.keys(components.types.blocks).forEach((blockName)=>{
+        (context.typesMap.icons[blockName] || []).forEach((icon)=>{
             [
                 ...JSON.stringify(icon).matchAll(regex)
             ].map((match)=>icons.add(match[1])

package/dist/build/buildRefs/buildRefs.js

@@ -14,6 +14,7 @@
   limitations under the License.
 */ import recursiveBuild from './recursiveBuild.js';
 import makeRefDefinition from './makeRefDefinition.js';
+// TODO: build operators aren't evaluated in lowdefy.yaml file. Move recursive call up a layer or something.
 async function buildRefs({ context  }) {
     const components = await recursiveBuild({
         context,

package/dist/build/buildRefs/evaluateBuildOperators.js

@@ -0,0 +1,35 @@
+/*
+  Copyright 2020-2021 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 { NodeParser } from '@lowdefy/operators';
+import operators from '@lowdefy/operators-js/operators/build';
+async function evaluateBuildOperators({ context , input , refDef  }) {
+    const operatorsParser = new NodeParser({
+        env: process.env,
+        operators
+    });
+    const { output , errors  } = operatorsParser.parse({
+        input,
+        location: refDef.path,
+        operatorPrefix: '_build.'
+    });
+    if (errors.length > 0) {
+        await context.logger.warn('Build operator errors.');
+        const promises = errors.map((error)=>context.logger.warn(error.message)
+        );
+        await promises;
+    }
+    return output;
+}
+export default evaluateBuildOperators;

package/dist/build/buildRefs/getRefContent.js

@@ -17,7 +17,7 @@ import parseRefContent from './parseRefContent.js';
 import runRefResolver from './runRefResolver.js';
 async function getRefContent({ context , refDef , referencedFrom  }) {
     let content;
-    if (refDef.path === 'lowdefy.yaml') {
+    if (refDef.path === 'lowdefy.yaml' || refDef.path === 'lowdefy.yml') {
         content = await getConfigFile({
             context,
             refDef,

package/dist/build/buildRefs/recursiveBuild.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 getRefContent from './getRefContent.js';
+*/ import evaluateBuildOperators from './evaluateBuildOperators.js';
+import getRefContent from './getRefContent.js';
 import getRefsFromFile from './getRefsFromFile.js';
 import populateRefs from './populateRefs.js';
 import runTransformer from './runTransformer.js';
@@ -46,9 +47,14 @@ async function recursiveParseFile({ context , refDef , count , referencedFrom  }
             count: count + 1,
             referencedFrom: refDef.path
         });
+        const evaluatedOperators = await evaluateBuildOperators({
+            context,
+            input: parsedFile,
+            refDef: parsedRefDef
+        });
         const transformedFile = await runTransformer({
             context,
-            parsedFile,
+            input: evaluatedOperators,
             refDef: parsedRefDef
         });
         parsedFiles[newRefDef.id] = transformedFile;

package/dist/build/buildRefs/runTransformer.js

@@ -13,18 +13,18 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import getUserJavascriptFunction from './getUserJavascriptFunction.js';
-async function runTransformer({ context , parsedFile , refDef  }) {
+async function runTransformer({ context , input , refDef  }) {
     if (refDef.transformer) {
         const transformerFn = await getUserJavascriptFunction({
             context,
             filePath: refDef.transformer
         });
         try {
-            return transformerFn(parsedFile, refDef.vars);
+            return transformerFn(input, refDef.vars);
         } catch (error) {
             throw Error(`Error calling transformer "${refDef.transformer}" from "${refDef.path}": ${error.message}`);
         }
     }
-    return parsedFile;
+    return input;
 }
 export default runTransformer;

package/dist/build/buildStyles.js

@@ -16,9 +16,9 @@
     components.styles = [];
     const styles = new Set();
     Object.entries(components.types.blocks).forEach(([blockName, block])=>{
-        styles.add(...(context.types.styles[block.package].default || []).map((style)=>`${block.package}/${style}`
+        styles.add(...(context.typesMap.styles.packages[block.package] || []).map((style)=>`${block.package}/${style}`
         ));
-        styles.add(...(context.types.styles[block.package][blockName] || []).map((style)=>`${block.package}/${style}`
+        styles.add(...(context.typesMap.styles.blocks[blockName] || []).map((style)=>`${block.package}/${style}`
         ));
     });
     components.styles = [

package/dist/build/buildTypes.js

@@ -23,6 +23,7 @@
             throw new Error(`${typeClass} type "${typeName}" was used but is not defined.`);
         }
         store[typeName] = {
+            originalTypeName: definitions[typeName].originalTypeName,
             package: definitions[typeName].package,
             version: definitions[typeName].version,
             count: counts[typeName]
@@ -46,38 +47,38 @@ function buildTypes({ components , context  }) {
     };
     buildTypeClass(context, {
         counter: typeCounters.actions,
-        definitions: context.types.actions,
+        definitions: context.typesMap.actions,
         store: components.types.actions,
         typeClass: 'Action'
     });
     buildTypeClass(context, {
         counter: typeCounters.blocks,
-        definitions: context.types.blocks,
+        definitions: context.typesMap.blocks,
         store: components.types.blocks,
         typeClass: 'Block'
     });
     buildTypeClass(context, {
         counter: typeCounters.connections,
-        definitions: context.types.connections,
+        definitions: context.typesMap.connections,
         store: components.types.connections,
         typeClass: 'Connection'
     });
     buildTypeClass(context, {
         counter: typeCounters.requests,
-        definitions: context.types.requests,
+        definitions: context.typesMap.requests,
         store: components.types.requests,
         typeClass: 'Request'
     });
     buildTypeClass(context, {
         counter: typeCounters.operators.client,
-        definitions: context.types.operators.client,
+        definitions: context.typesMap.operators.client,
         store: components.types.operators.client,
         typeClass: 'Operator',
         warnIfMissing: true
     });
     buildTypeClass(context, {
         counter: typeCounters.operators.server,
-        definitions: context.types.operators.server,
+        definitions: context.typesMap.operators.server,
         store: components.types.operators.server,
         typeClass: 'Operator',
         warnIfMissing: true

package/dist/build/writePluginImports/generateImportFile.js

@@ -14,18 +14,18 @@
   limitations under the License.
 */ import { nunjucksFunction } from '@lowdefy/nunjucks';
 const template = `{%- for import in imports -%}
-import { {{ import.type }} } from '{{ import.package }}/{{ importPath }}';
+import { {{ import.originalTypeName }} as {{ import.typeName }} } from '{{ import.package }}/{{ importPath }}';
 {% endfor -%}
 export default {
   {% for import in imports -%}
-  {{ import.type }},
+  {{ import.typeName }},
   {% endfor -%}
-}`;
+};`;
 function generateImportFile({ types , importPath  }) {
     const templateFn = nunjucksFunction(template);
-    const imports = Object.keys(types).map((type)=>({
-            type,
-            ...types[type]
+    const imports = Object.keys(types).map((typeName)=>({
+            typeName,
+            ...types[typeName]
         })
     );
     return templateFn({