@komaci/esm-generator 244.1.4 → 244.1.7

package/build/__tests__/adgAstGeneration.spec.js

@@ -56,68 +56,86 @@ describe('composeAdgStaticMetadata', () => {
         expect(properties).toHaveLength(4);
         expect(properties[0].value.value).toBe('c-test-comp__base');
     });
-    it('creates a static metadata object with child metadata and true for img', () => {
-        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
-        const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
-        adg.exportName = 'default';
-        moduleMetadata.staticMetadataId = 'c-test-comp';
-        adg.compositionRootIndex = 0;
-        adg.compositions = [
-            {
-                type: 'Container',
-                compositions: [
-                    {
-                        type: 'ComposedAdg',
-                        input: { type: 'ImportReference', value: 'test' },
-                        properties: {
-                            attr1: { type: 'Binding', value: 'input1' },
-                            attr2: { type: 'Binding', value: 'input2' },
-                            attr3: { type: 'PrimitiveValue', value: 'Literal!' },
-                        },
-                    },
+    describe('static metadata for component with image', () => {
+        const enablePropMetadata = [false, true];
+        for (const propMetadataEnabled of enablePropMetadata) {
+            it(`creates a static metadata object with child metadata ${propMetadataEnabled ? 'with props' : 'WITHOUT props'} and true for img`, () => {
+                const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+                if (propMetadataEnabled) {
+                    moduleMetadata.includePropsMetadata = true;
+                }
+                const adg = (0, common_shared_1.initAdgMetadataObject)('adg0');
+                adg.exportName = 'default';
+                moduleMetadata.staticMetadataId = 'c-test-comp';
+                adg.compositionRootIndex = 0;
+                adg.compositions = [
                     {
-                        type: 'Image',
-                        src: { type: 'Binding', value: 'input1' },
+                        type: 'Container',
+                        compositions: [
+                            {
+                                type: 'ComposedAdg',
+                                input: { type: 'ImportReference', value: 'test' },
+                                properties: {
+                                    attr1: { type: 'Binding', value: 'input1' },
+                                    attr2: { type: 'Binding', value: 'input2' },
+                                    attr3: { type: 'PrimitiveValue', value: 'Literal!' },
+                                },
+                            },
+                            {
+                                type: 'Image',
+                                src: { type: 'Binding', value: 'input1' },
+                            },
+                        ],
                     },
-                ],
-            },
-        ];
-        moduleMetadata.importIndexReference.set('test', 'import1');
-        moduleMetadata.importsByName.set('import1', {
-            generatorAlias: 'i0',
-            name: '',
-            resourceName: '',
-            komaciDocImportRef: '',
-            isFromInternalNamespace: false,
-            isFromSupportedLibrary: false,
-            usedInPriming: false,
-            staticallyAnalyzable: false,
-        });
-        const res = (0, functionAstGeneration_1.composeAdgStaticMetadata)(adg, moduleMetadata);
-        expect(res.type).toBe('VariableDeclaration');
-        const varDeclarator = res.declarations[0];
-        expect(varDeclarator.id.name).toBe('adg0Meta');
-        const properties = varDeclarator.init.properties;
-        expect(properties).toHaveLength(4);
-        expect(properties[0].value.value).toBe('c-test-comp');
-        expect(properties[1].value
-            .properties[0].value.type).toBe('ArrayExpression');
-        const childMetaArr = properties[1].value
-            .properties[0].value;
-        expect(childMetaArr.elements).toHaveLength(2);
-        expect(childMetaArr.elements[0].properties).toHaveLength(2);
-        expect(childMetaArr.elements[1].properties).toHaveLength(1);
-        expect(childMetaArr.elements[0].properties).toHaveLength(2);
-        const prop1 = childMetaArr.elements[0]
-            .properties[0];
-        expect(prop1.value.name).toEqual('i0');
-        const prop2 = childMetaArr.elements[0]
-            .properties[1];
-        expect(prop2.value.properties).toHaveLength(3);
-        const propObj = prop2.value.properties[0].value;
-        expect(propObj.properties[1].value.value).toEqual('input1');
-        expect(childMetaArr.elements[1].properties).toHaveLength(1);
-        expect(properties[3].value.value).toBeTruthy();
+                ];
+                moduleMetadata.importIndexReference.set('test', 'import1');
+                moduleMetadata.importsByName.set('import1', {
+                    generatorAlias: 'i0',
+                    name: '',
+                    resourceName: '',
+                    komaciDocImportRef: '',
+                    isFromInternalNamespace: false,
+                    isFromSupportedLibrary: false,
+                    usedInPriming: false,
+                    staticallyAnalyzable: false,
+                });
+                const res = (0, functionAstGeneration_1.composeAdgStaticMetadata)(adg, moduleMetadata);
+                expect(res.type).toBe('VariableDeclaration');
+                const varDeclarator = res.declarations[0];
+                expect(varDeclarator.id.name).toBe('adg0Meta');
+                const properties = varDeclarator.init.properties;
+                expect(properties).toHaveLength(4);
+                expect(properties[0].value.value).toBe('c-test-comp');
+                expect(properties[1].value
+                    .properties[0].value.type).toBe('ArrayExpression');
+                const childMetaArr = properties[1].value
+                    .properties[0].value;
+                expect(childMetaArr.elements).toHaveLength(2);
+                // should have two elements, one for the adg ("a") and another for the props ("p")
+                // when propMetadata enabled; otherwise only 1 for the adg ("a")
+                const expectedNumElementsForChildMetadata = propMetadataEnabled ? 2 : 1;
+                expect(childMetaArr.elements[0].properties).toHaveLength(expectedNumElementsForChildMetadata);
+                expect(childMetaArr.elements[1].properties).toHaveLength(1);
+                expect(childMetaArr.elements[0].properties).toHaveLength(expectedNumElementsForChildMetadata);
+                const prop1 = childMetaArr.elements[0]
+                    .properties[0];
+                expect(prop1.value.name).toEqual('i0');
+                const prop2 = childMetaArr.elements[0]
+                    .properties[1];
+                if (propMetadataEnabled) {
+                    expect(prop2.value.properties).toHaveLength(3);
+                    const propObj = prop2.value.properties[0].value;
+                    expect(propObj.properties[1].value
+                        .value).toEqual('input1');
+                }
+                else {
+                    // no prop metadata if propMetadata is false
+                    expect(prop2).toBeUndefined();
+                }
+                expect(childMetaArr.elements[1].properties).toHaveLength(1);
+                expect(properties[3].value.value).toBeTruthy();
+            });
+        }
     });
     it('static meta data object has true for PF', () => {
         const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();

package/build/__tests__/compositionAstGeneration.spec.js

@@ -35,6 +35,7 @@ const common_shared_1 = require("@komaci/common-shared");
 const generator_1 = __importDefault(require("@babel/generator"));
 const complexDoc = JSON.parse(fs.readFileSync((0, path_1.join)(__dirname, './general-komaci-docs/complexTemplateDoc/template.json'), 'utf-8'));
 describe('imageToExpression', () => {
+    const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
     it('should return an expression for a KomaciDocument Image node', () => {
         const komaciDocImagePrimitive = {
             type: 'Image',
@@ -43,13 +44,13 @@ describe('imageToExpression', () => {
                 value: 'testPrimitive.jpg', // this is string literal of a relative URL
             },
         };
-        let expression = (0, compositionAstGeneration_1.imageToExpression)(komaciDocImagePrimitive);
+        let expression = (0, compositionAstGeneration_1.imageToExpression)(moduleMetadata, komaciDocImagePrimitive);
         expect(expression.type).toBe('CallExpression');
         let callExpression = expression;
         expect(callExpression).not.toBeUndefined();
         expect(callExpression.callee).toBe(types_2.ID.IMG_FUNC);
         expect(callExpression.arguments).not.toBeUndefined();
-        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments).toHaveLength(2);
         expect(callExpression.arguments[0]).not.toBeUndefined();
         expect(callExpression.arguments[0].type).toBe('ObjectExpression');
         let objExpression = callExpression
@@ -59,7 +60,8 @@ describe('imageToExpression', () => {
         expect(objExpression.properties[0].type).toBe('ObjectProperty');
         let objProperty = objExpression.properties[0];
         expect(objProperty.key).toBe(types_2.ID.IMG_SRC);
-        expect(objProperty.value).toEqual((0, types_1.stringLiteral)('testPrimitive.jpg')); // img({src: "testPrimitive.jpg"})
+        expect(objProperty.value.properties[1]
+            .value).toEqual((0, types_1.stringLiteral)('testPrimitive.jpg')); // img({src: "testPrimitive.jpg"})
         const komaciDocImageBinding = {
             type: 'Image',
             src: {
@@ -67,13 +69,13 @@ describe('imageToExpression', () => {
                 value: 'testBinding', // this is a string literal, but represents a variable name
             },
         };
-        expression = (0, compositionAstGeneration_1.imageToExpression)(komaciDocImageBinding);
+        expression = (0, compositionAstGeneration_1.imageToExpression)(moduleMetadata, komaciDocImageBinding);
         expect(expression.type).toBe('CallExpression');
         callExpression = expression;
         expect(callExpression).not.toBeUndefined();
         expect(callExpression.callee).toBe(types_2.ID.IMG_FUNC);
         expect(callExpression.arguments).not.toBeUndefined();
-        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments).toHaveLength(2);
         expect(callExpression.arguments[0]).not.toBeUndefined();
         expect(callExpression.arguments[0].type).toBe('ObjectExpression');
         objExpression = callExpression.arguments[0];
@@ -83,12 +85,13 @@ describe('imageToExpression', () => {
         expect(objExpression.properties[0].type).toBe('ObjectProperty');
         objProperty = objExpression.properties[0];
         expect(objProperty.key).toBe(types_2.ID.IMG_SRC);
-        let segments = ['ctx', 'props', 'testBinding'];
+        const segments = ['ctx', 'props', 'testBinding'];
         let expr = (0, types_1.identifier)(segments[0]);
         for (let i = 1; i < segments.length; i++) {
             expr = (0, types_1.optionalMemberExpression)(expr, (0, types_1.identifier)(segments[i]), false, false);
         }
-        expect(objProperty.value).toEqual(expr); // img({src: ctx.props.testBinding})
+        expect(objProperty.value.properties[1]
+            .value).toEqual((0, types_1.stringLiteral)('testBinding')); // img({src: ctx.props.testBinding})
         const komaciDocImageNestedBinding = {
             type: 'Image',
             src: {
@@ -96,13 +99,13 @@ describe('imageToExpression', () => {
                 value: 'imageObject/nested/imageName', // this is a string literal, represents nested-scoped variable names
             },
         };
-        expression = (0, compositionAstGeneration_1.imageToExpression)(komaciDocImageNestedBinding);
+        expression = (0, compositionAstGeneration_1.imageToExpression)(moduleMetadata, komaciDocImageNestedBinding);
         expect(expression.type).toBe('CallExpression');
         callExpression = expression;
         expect(callExpression).not.toBeUndefined();
         expect(callExpression.callee).toBe(types_2.ID.IMG_FUNC);
         expect(callExpression.arguments).not.toBeUndefined();
-        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments).toHaveLength(2);
         expect(callExpression.arguments[0]).not.toBeUndefined();
         expect(callExpression.arguments[0].type).toBe('ObjectExpression');
         objExpression = callExpression.arguments[0];
@@ -112,13 +115,8 @@ describe('imageToExpression', () => {
         expect(objExpression.properties[0].type).toBe('ObjectProperty');
         objProperty = objExpression.properties[0];
         expect(objProperty.key).toBe(types_2.ID.IMG_SRC);
-        segments = ['ctx', 'props', 'imageObject', 'nested', 'imageName'];
-        expr = (0, types_1.identifier)(segments[0]);
-        const chainingStartIdx = 2;
-        for (let i = 1; i < segments.length; i++) {
-            expr = (0, types_1.optionalMemberExpression)(expr, (0, types_1.identifier)(segments[i]), false, i > chainingStartIdx);
-        }
-        expect(objProperty.value).toEqual(expr); // img({src: ctx.props.imageObject?.nested?.imageName})
+        expect(objProperty.value.properties[1]
+            .value).toEqual((0, types_1.stringLiteral)('imageObject.nested.imageName'));
     });
     it('should not return an expression for invalid KomaciDocument Image nodes due to invalid src.value type (boolean)', () => {
         const komaciDocImagePrimitive = {
@@ -128,14 +126,14 @@ describe('imageToExpression', () => {
                 value: false, // not a supported type (boolean)
             },
         };
-        const expression = (0, compositionAstGeneration_1.imageToExpression)(komaciDocImagePrimitive);
+        const expression = (0, compositionAstGeneration_1.imageToExpression)(moduleMetadata, komaciDocImagePrimitive);
         expect(expression.type).toBe('CallExpression');
         const callExpression = expression;
         expect(callExpression).not.toBeUndefined();
         expect(callExpression.callee).not.toBeUndefined();
         expect(callExpression.callee).toBe(types_2.ID.IMG_FUNC);
         expect(callExpression.arguments).not.toBeUndefined();
-        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments).toHaveLength(2);
         expect(callExpression.arguments[0].type).toBe('ObjectExpression');
         const objExpression = callExpression
             .arguments[0];
@@ -150,15 +148,15 @@ describe('imageToExpression', () => {
                 value: '', // blanks not supported
             },
         };
-        let expression = (0, compositionAstGeneration_1.imageToExpression)(komaciDocImagePrimitiveBlank);
-        expression = (0, compositionAstGeneration_1.imageToExpression)(komaciDocImagePrimitiveBlank);
+        let expression = (0, compositionAstGeneration_1.imageToExpression)(moduleMetadata, komaciDocImagePrimitiveBlank);
+        expression = (0, compositionAstGeneration_1.imageToExpression)(moduleMetadata, komaciDocImagePrimitiveBlank);
         expect(expression.type).toBe('CallExpression');
         const callExpression = expression;
         expect(callExpression).not.toBeUndefined();
         expect(callExpression.callee).not.toBeUndefined();
         expect(callExpression.callee).toBe(types_2.ID.IMG_FUNC);
         expect(callExpression.arguments).not.toBeUndefined();
-        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments).toHaveLength(2);
         expect(callExpression.arguments[0].type).toBe('ObjectExpression');
         const objExpression = callExpression
             .arguments[0];
@@ -175,15 +173,15 @@ describe('imageToExpression', () => {
         };
         // change the src.value type to something invalid, a number
         komaciDocImageInvalidSrcValType.src.value = 12345;
-        let expression = (0, compositionAstGeneration_1.imageToExpression)(komaciDocImageInvalidSrcValType);
-        expression = (0, compositionAstGeneration_1.imageToExpression)(komaciDocImageInvalidSrcValType);
+        let expression = (0, compositionAstGeneration_1.imageToExpression)(moduleMetadata, komaciDocImageInvalidSrcValType);
+        expression = (0, compositionAstGeneration_1.imageToExpression)(moduleMetadata, komaciDocImageInvalidSrcValType);
         expect(expression.type).toBe('CallExpression');
         const callExpression = expression;
         expect(callExpression).not.toBeUndefined();
         expect(callExpression.callee).not.toBeUndefined();
         expect(callExpression.callee).toBe(types_2.ID.IMG_FUNC);
         expect(callExpression.arguments).not.toBeUndefined();
-        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments).toHaveLength(2);
         expect(callExpression.arguments[0].type).toBe('ObjectExpression');
         const objExpression = callExpression
             .arguments[0];
@@ -218,23 +216,66 @@ describe('compositionToExpression', () => {
     (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(complexDoc, moduleMetadata, 0);
     moduleMetadata.adgs.set(0, (0, common_shared_1.initAdgMetadataObject)('adg0'));
     (0, common_shared_1.addTemplateUsageForAdg)(complexDoc, 0, moduleMetadata);
-    it('effectiely builds a conditional expression for a component with isActive', () => {
+    it('effectively builds a conditional expression for a component with isActive', () => {
         const res = (0, compositionAstGeneration_1.compositionToExpression)(moduleMetadata, complexDoc.compositions[0].compositions[2].compositions[1]);
-        expect(res.type).toBe('ConditionalExpression');
+        expect(res.type).toBe('CallExpression');
+        expect(res.callee).toBe(types_2.ID.CONDITION_FUNC);
         const code = (0, generator_1.default)(res).code;
-        expect(code).toBe('u(ctx.props.apexResult) || ctx.props.apexResult ? [i(ctx.props.apexResult?.data?.names, ctx, user_var_test => {\n  return [e({}, ctx, []), cg(i4, {\n    componentId: "c-name-detail",\n    props: {\n      name: user_var_test.value?.name\n    }\n  }, ctx)];\n}), u(ctx.props.apexResult) || ctx.props.apexResult?.data ? i(ctx.props.apexResult?.data, ctx, user_var_contactName => {\n  return [e({}, ctx, [])];\n}) : undefined, u(ctx.props.apexResult) || ctx.props.apexResult?.error ? [] : undefined] : undefined');
+        expect(code).toBe(`c(ctx, {
+  c: {
+    t: "b",
+    v: "apexResult"
+  },
+  slot: ""
+}, ctx => [i({
+  c: {
+    t: "b",
+    v: "apexResult.data.names"
+  }
+}, ctx, user_var_test => {
+  return [e({}, ctx, []), cg(i4, {
+    componentId: "c-name-detail",
+    props: ctx => ({
+      name: user_var_test.value?.name
+    })
+  }, ctx, [], [])];
+}), c(ctx, {
+  c: {
+    t: "b",
+    v: "apexResult.data"
+  }
+}, ctx => i({
+  c: {
+    t: "b",
+    v: "apexResult.data"
+  }
+}, ctx, user_var_contactName => {
+  return [e({}, ctx, [])];
+}), false), c(ctx, {
+  c: {
+    t: "b",
+    v: "apexResult.error"
+  }
+}, ctx => [], false)], false)`);
     });
     it('effectiely builds a conditional expression for a component with negated isActive', () => {
         const res = (0, compositionAstGeneration_1.compositionToExpression)(moduleMetadata, complexDoc.compositions[0].compositions[2].compositions[2]);
-        expect(res.type).toBe('ConditionalExpression');
+        expect(res.type).toBe('CallExpression');
+        expect(res.callee).toBe(types_2.ID.CONDITION_FUNC);
         const code = (0, generator_1.default)(res).code;
-        expect(code).toBe('u(ctx.props.apexResult) || !ctx.props.apexResult ? [] : undefined');
+        expect(code).toBe(`c(ctx, {
+  c: {
+    t: "b",
+    v: "apexResult"
+  },
+  slot: ""
+}, ctx => [], true)`);
     });
     it('returns a basic reference when isActive is not set', () => {
         const res = (0, compositionAstGeneration_1.compositionToExpression)(moduleMetadata, complexDoc.compositions[0].compositions[2].compositions[0]);
         expect(res.type).toBe('CallExpression');
         const code = (0, generator_1.default)(res).code;
-        expect(code).toBe('cg(i1, {\n  slot: "title",\n  componentId: "c-title",\n  props: {\n    icon: "standard:apex",\n    size: "medium"\n  }\n}, ctx)');
+        expect(code).toBe('cg(i1, {\n  slot: "title",\n  componentId: "c-title",\n  props: ctx => ({\n    icon: "standard:apex",\n    size: "medium"\n  })\n}, ctx, [], [])');
     });
 });
 describe('containerToExpression', () => {
@@ -273,14 +314,109 @@ describe('composedAdgToExpression', () => {
         expect(res.type).toBe('CallExpression');
         expect(res.callee.name).toBe('cg');
         const code = (0, generator_1.default)(res).code;
-        expect(code).toBe('cg(i3, {\n  componentId: "c-lookup-field-row",\n  props: {\n    label: "CreatedBy User Info",\n    objectApiName: "User",\n    recordId: ctx.props.record?.data?.fields?.CreatedById?.value\n  }\n}, ctx)');
+        expect(code).toBe('cg(i3, {\n  componentId: "c-lookup-field-row",\n  props: ctx => ({\n    label: "CreatedBy User Info",\n    objectApiName: "User",\n    recordId: ctx.props.record?.data?.fields?.CreatedById?.value\n  })\n}, ctx, [], ["record"])');
     });
     it('properly composed composedAdg with children', () => {
         const res = (0, compositionAstGeneration_1.composedAdgToExpression)(moduleMetadata, complexDoc.compositions[0].compositions[0]);
         expect(res.type).toBe('CallExpression');
         expect(res.callee.name).toBe('cg');
         const code = (0, generator_1.default)(res).code;
-        expect(code).toBe('cg(i0, {\n  componentId: "lightning-card",\n  props: {}\n}, ctx, [cg(i1, {\n  slot: "title",\n  componentId: "c-title",\n  props: {\n    icon: "standard:account",\n    size: "large"\n  }\n}, ctx), u(ctx.props.record) || ctx.props.record?.data ? [cg(i2, {\n  componentId: "c-fieldrow",\n  props: {\n    label: "Object Type",\n    value: ctx.props.objectApiName\n  }\n}, ctx), cg(i2, {\n  componentId: "c-fieldrow",\n  props: {\n    label: "Account Id",\n    value: ctx.props.record?.data?.fields?.Id?.value\n  }\n}, ctx), cg(i2, {\n  componentId: "c-fieldrow",\n  props: {\n    label: "Account Name",\n    value: ctx.props.record?.data?.fields?.Name?.value\n  }\n}, ctx), u(ctx.props.ownerRecord) || ctx.props.ownerRecord?.data ? cg(i2, {\n  componentId: "c-fieldrow",\n  props: {\n    label: "Account Owner",\n    value: ctx.props.ownerRecord?.data?.fields?.Name?.value\n  }\n}, ctx) : undefined, u(ctx.props.createdByRecord) || ctx.props.createdByRecord?.data ? cg(i2, {\n  componentId: "c-fieldrow",\n  props: {\n    label: "Created By",\n    value: ctx.props.createdByRecord?.data?.fields?.Name?.value\n  }\n}, ctx) : undefined] : undefined])');
+        expect(code).toBe(`cg(i0, {
+  componentId: "lightning-card",
+  props: ctx => ({})
+}, ctx, [cg(i1, {
+  slot: "title",
+  componentId: "c-title",
+  props: ctx => ({
+    icon: "standard:account",
+    size: "large"
+  })
+}, ctx, [], []), c(ctx, {
+  c: {
+    t: "b",
+    v: "record.data"
+  },
+  slot: ""
+}, ctx => [cg(i2, {
+  componentId: "c-fieldrow",
+  props: ctx => ({
+    label: "Object Type",
+    value: ctx.props.objectApiName
+  })
+}, ctx, [], ["objectApiName"]), cg(i2, {
+  componentId: "c-fieldrow",
+  props: ctx => ({
+    label: "Account Id",
+    value: ctx.props.record?.data?.fields?.Id?.value
+  })
+}, ctx, [], ["record"]), cg(i2, {
+  componentId: "c-fieldrow",
+  props: ctx => ({
+    label: "Account Name",
+    value: ctx.props.record?.data?.fields?.Name?.value
+  })
+}, ctx, [], ["record"]), c(ctx, {
+  c: {
+    t: "b",
+    v: "ownerRecord.data"
+  }
+}, ctx => cg(i2, {
+  componentId: "c-fieldrow",
+  props: ctx => ({
+    label: "Account Owner",
+    value: ctx.props.ownerRecord?.data?.fields?.Name?.value
+  })
+}, ctx, [], ["ownerRecord"]), false), c(ctx, {
+  c: {
+    t: "b",
+    v: "createdByRecord.data"
+  }
+}, ctx => cg(i2, {
+  componentId: "c-fieldrow",
+  props: ctx => ({
+    label: "Created By",
+    value: ctx.props.createdByRecord?.data?.fields?.Name?.value
+  })
+}, ctx, [], ["createdByRecord"]), false)], false)], [])`);
+    });
+    it('properly generated dependentProps', () => {
+        const res = (0, compositionAstGeneration_1.composedAdgToExpression)(moduleMetadata, {
+            type: 'ComposedAdg',
+            input: {
+                type: 'ImportReference',
+                value: 't0-0/names/0',
+            },
+            properties: {
+                attr1: {
+                    type: 'Binding',
+                    value: 'recordId',
+                },
+                attr2: {
+                    type: 'Binding',
+                    value: 'recordId',
+                },
+                attr3: {
+                    type: 'Binding',
+                    value: 'record',
+                },
+                attr4: {
+                    type: 'Binding',
+                    value: 'record/data/Name',
+                },
+            },
+        });
+        expect(res.type).toBe('CallExpression');
+        expect(res.callee.name).toBe('cg');
+        const code = (0, generator_1.default)(res).code;
+        expect(code).toBe(`cg(i0, {
+  componentId: "lightning-card",
+  props: ctx => ({
+    attr1: ctx.props.recordId,
+    attr2: ctx.props.recordId,
+    attr3: ctx.props.record,
+    attr4: ctx.props.record?.data?.Name
+  })
+}, ctx, [], ["recordId", "record"])`);
     });
 });
 describe('iterationToExpression', () => {
@@ -321,7 +457,92 @@ describe('iterationToExpression', () => {
         expect(res.type).toBe('CallExpression');
         expect(res.callee.name).toBe('i');
         const code = (0, generator_1.default)(res).code;
-        expect(code).toBe('i(ctx.props.contacts, ctx, user_var_contact => {\n  return [cg(i0, {\n    componentId: "lightning-card",\n    props: {\n      label: user_var_contact.value?.Name,\n      myIndex: user_var_contact.index\n    }\n  }, ctx)];\n})');
+        expect(code).toBe(`i({
+  c: {
+    t: "b",
+    v: "contacts"
+  }
+}, ctx, user_var_contact => {
+  return [cg(i0, {
+    componentId: "lightning-card",
+    props: ctx => ({
+      label: user_var_contact.value?.Name,
+      myIndex: user_var_contact.index
+    })
+  }, ctx, [], [])];
+})`);
+    });
+    it('can compose an iteration factory call from a two nested iterator composition', () => {
+        const res = (0, compositionAstGeneration_1.iterationToExpression)(moduleMetadata, {
+            type: 'Iteration',
+            input: {
+                type: 'Binding',
+                value: 'contacts',
+            },
+            iterator: 'contact',
+            compositions: [
+                {
+                    type: 'Iteration',
+                    input: {
+                        type: 'Binding',
+                        value: 'actions',
+                    },
+                    iterator: 'action',
+                    compositions: [
+                        {
+                            type: 'ComposedAdg',
+                            input: {
+                                type: 'ImportReference',
+                                value: 't0-0/names/0',
+                            },
+                            properties: {
+                                label: {
+                                    type: 'Binding',
+                                    value: 'contact/value/Name',
+                                },
+                                myIndex: {
+                                    type: 'Binding',
+                                    value: 'contact/index',
+                                },
+                                actionName: {
+                                    type: 'Binding',
+                                    value: 'action/name',
+                                },
+                            },
+                            key: {
+                                type: 'Binding',
+                                value: 'contact/value/Id',
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+        expect(res.type).toBe('CallExpression');
+        expect(res.callee.name).toBe('i');
+        const code = (0, generator_1.default)(res).code;
+        expect(code).toBe(`i({
+  c: {
+    t: "b",
+    v: "contacts"
+  }
+}, ctx, user_var_contact => {
+  return [i({
+    c: {
+      t: "b",
+      v: "actions"
+    }
+  }, ctx, user_var_action => {
+    return [cg(i0, {
+      componentId: "lightning-card",
+      props: ctx => ({
+        actionName: user_var_action.name,
+        label: user_var_contact.value?.Name,
+        myIndex: user_var_contact.index
+      })
+    }, ctx, [], [])];
+  })];
+})`);
     });
 });
 describe('slotToExpression', () => {
@@ -372,7 +593,7 @@ describe('getCompositionConfig', () => {
     it('collects composition config for a composedAdg', () => {
         const res = (0, compositionAstGeneration_1.getCompositionConfig)(complexDoc.compositions[0].compositions[2].compositions[0]);
         const code = (0, generator_1.default)(res).code;
-        expect(code).toBe('{\n  slot: "title",\n  props: {\n    icon: "standard:apex",\n    size: "medium"\n  }\n}');
+        expect(code).toBe('{\n  slot: "title",\n  props: ctx => ({\n    icon: "standard:apex",\n    size: "medium"\n  })\n}');
     });
     it('generates duplicate composition configs for similar composedAdgs', () => {
         const res = (0, compositionAstGeneration_1.getCompositionConfig)(complexDoc.compositions[0].compositions[2].compositions[0]);
@@ -397,7 +618,7 @@ describe('getCompositionConfig', () => {
         });
         const swappedCode = (0, generator_1.default)(swapRes).code;
         const code = (0, generator_1.default)(res).code;
-        const expected = '{\n  slot: "title",\n  props: {\n    icon: "standard:apex",\n    size: "medium"\n  }\n}';
+        const expected = '{\n  slot: "title",\n  props: ctx => ({\n    icon: "standard:apex",\n    size: "medium"\n  })\n}';
         expect(code).toBe(expected);
         expect(swappedCode).toBe(expected);
     });
@@ -445,14 +666,11 @@ describe('getCompositionConfig', () => {
                 },
             },
         });
-        expect(res.properties[0].value
-            .properties[0].key.type).toBe('Identifier');
-        expect(res.properties[0].value
-            .properties[1].key.type).toBe('StringLiteral');
-        expect(res.properties[0].value
-            .properties[2].key.type).toBe('Identifier');
-        expect(res.properties[0].value
-            .properties[3].key.type).toBe('StringLiteral');
+        const functionBody = res.properties[0].value.body;
+        expect(functionBody.properties[0].key.type).toBe('Identifier');
+        expect(functionBody.properties[1].key.type).toBe('StringLiteral');
+        expect(functionBody.properties[2].key.type).toBe('Identifier');
+        expect(functionBody.properties[3].key.type).toBe('StringLiteral');
     });
 });
 //# sourceMappingURL=compositionAstGeneration.spec.js.map

package/build/__tests__/functionAstGeneration.spec.js

@@ -571,4 +571,15 @@ describe('composeStaticMetadataAssignmentExpression', () => {
         expect(right.name).toBe('Adg0Meta');
     });
 });
+describe('composeSelfServiceAssignmentExpression', () => {
+    it('returns proper expression statement', () => {
+        const expr = (0, functionAstGeneration_1.composeSelfServiceAssignmentExpression)('adg0')
+            .expression;
+        const left = expr.left;
+        expect(left.object.name).toBe('adg0');
+        expect(left.property.name).toBe('self');
+        const right = expr.right;
+        expect(right.value).toBeTruthy();
+    });
+});
 //# sourceMappingURL=functionAstGeneration.spec.js.map

package/build/__tests__/genericAstGeneration.spec.js

@@ -922,4 +922,48 @@ describe('collectMetadataForImportedTemplates', () => {
         expect(moduleMetadata.adgs.get(1)?.properties.size).toBe(2);
     });
 });
+describe('valueReferenceToExpression', () => {
+    it('properly references the property that we want to refernce as a string', () => {
+        const obj = (0, genericAstGeneration_1.valueReferenceToExpression)((0, common_shared_1.initModuleMetadataObject)(), {
+            type: 'Binding',
+            value: 'record/sub/path',
+        });
+        expect(obj.properties[0].key.name).toBe('t');
+        expect(obj.properties[0].value.value).toBe('b');
+        expect(obj.properties[1].key.name).toBe('v');
+        expect(obj.properties[1].value.value).toBe('record.sub.path');
+    });
+    it('properly references a binding in an iteration context by value', () => {
+        const obj = (0, genericAstGeneration_1.valueReferenceToExpression)((0, common_shared_1.initModuleMetadataObject)(), {
+            type: 'Binding',
+            value: 'item/val',
+        }, ['item']);
+        expect(obj.properties[0].key.name).toBe('t');
+        expect(obj.properties[0].value.value).toBe('s');
+        expect(obj.properties[1].key.name).toBe('v');
+        expect(obj.properties[1]
+            .value.object.name).toBe('user_var_item');
+        expect(obj.properties[1]
+            .value.property.name).toBe('val');
+    });
+    it('handles whatever this weird typing edge case is where value is undefined', () => {
+        const obj = (0, genericAstGeneration_1.valueReferenceToExpression)((0, common_shared_1.initModuleMetadataObject)(), {
+            type: 'PrimitiveValue',
+        });
+        expect(obj.properties[0].key.name).toBe('t');
+        expect(obj.properties[0].value.value).toBe('s');
+        expect(obj.properties[1].key.name).toBe('v');
+        expect(obj.properties[1].value.name).toBe('undefined');
+    });
+    it('properly references a static value', () => {
+        const obj = (0, genericAstGeneration_1.valueReferenceToExpression)((0, common_shared_1.initModuleMetadataObject)(), {
+            type: 'PrimitiveValue',
+            value: 'reference',
+        });
+        expect(obj.properties[0].key.name).toBe('t');
+        expect(obj.properties[0].value.value).toBe('s');
+        expect(obj.properties[1].key.name).toBe('v');
+        expect(obj.properties[1].value.value).toBe('reference');
+    });
+});
 //# sourceMappingURL=genericAstGeneration.spec.js.map

package/build/__tests__/komaci-bundle-module.fixtures.spec.js

@@ -38,7 +38,7 @@ function generateModuleSource(komaciHTMLDoc, komaciJSDoc, srcFileMap) {
 // eslint-disable-next-line jest/no-disabled-tests
 describe('fixtures', () => {
     // find all folder paths containing a file whose name ends in ".src"
-    const fixtures = glob_1.default.sync(path_1.default.resolve(FIXTURES_DIR, '**/*.src'));
+    const fixtures = glob_1.default.sync(path_1.default.resolve(FIXTURES_DIR, '**/*.json'));
     for (const caseEntry of fixtures) {
         const caseFolder = path_1.default.dirname(caseEntry);
         const caseName = path_1.default.relative(FIXTURES_DIR, caseFolder);

package/build/compositionAstGeneration.d.ts

@@ -63,14 +63,15 @@ export declare function slotToExpression(moduleMetadata: ModuleMetadata, slot: S
  * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
  * @returns {Expression} the babel Expression representing the Image prompt into the Resolver API
  */
-export declare function imageToExpression(image: Image, iterationContext?: string[]): t.Expression;
+export declare function imageToExpression(moduleMetadata: ModuleMetadata, image: Image, iterationContext?: string[]): t.Expression;
 /**
  * Creates a babel configuration ObjectExpression for provided composition. This is the `CompositionConfig`
  * from Resolver API in its babel ObjectExpression form.
  * @param {ComposedAdg | Container | Slot} composition the Composition from which to create a configuration (as a ComposedAdg, Container, or Slot)
  * @param {string} componentId the component indentifier, as a string
  * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @param {t.Expression[]} dependentProps list of properties which are dependencies of this composition
  * @returns {ObjectExpression} the babel ObjectExpression representing the Resolver API CompositionConfig
  */
-export declare function getCompositionConfig(composition: ComposedAdg | Container | Slot, componentId?: string, iterationContext?: string[]): t.ObjectExpression;
+export declare function getCompositionConfig(composition: ComposedAdg | Container | Slot | Iteration, componentId?: string, iterationContext?: string[], dependentProps?: Set<string>): t.ObjectExpression;
 //# sourceMappingURL=compositionAstGeneration.d.ts.map

package/build/compositionAstGeneration.js

@@ -91,20 +91,26 @@ function compositionToExpression(moduleMetadata, composition, iterationContext)
             expression = slotToExpression(moduleMetadata, composition, iterationContext);
             break;
         case 'Image':
-            expression = imageToExpression(composition, iterationContext);
+            expression = imageToExpression(moduleMetadata, composition, iterationContext);
             break;
     }
     // If the composition has an isActive condition, then
     // expression needs to be proceded by a conditional check.
     if (composition.isActive) {
-        let conditionalTest = (0, genericAstGeneration_1.bindingToExpression)(composition.isActive.input, iterationContext);
-        if (composition.isActive.negate) {
-            conditionalTest = t.unaryExpression('!', conditionalTest);
+        const props = [
+            t.objectProperty(t.identifier('c'), (0, genericAstGeneration_1.valueReferenceToExpression)(moduleMetadata, composition.isActive.input, iterationContext)),
+        ];
+        const container = composition;
+        if (container.slot !== undefined) {
+            props.push(t.objectProperty(t.identifier('slot'), t.stringLiteral(container.slot)));
         }
-        const prop = (0, genericAstGeneration_1.bindingToExpression)(composition.isActive.input, iterationContext, true);
-        const unresolvedTest = t.callExpression(types_1.ID.UNRESOLVED_FUNC, [prop]);
-        const test = t.logicalExpression('||', unresolvedTest, conditionalTest);
-        expression = t.conditionalExpression(test, expression, types_1.ID.UNDEFINED);
+        const compositionFunc = t.arrowFunctionExpression([types_1.ID.CONTEXT], expression);
+        expression = t.callExpression(types_1.ID.CONDITION_FUNC, [
+            types_1.ID.CONTEXT,
+            t.objectExpression(props),
+            compositionFunc,
+            t.booleanLiteral(composition.isActive.negate || false),
+        ]);
     }
     return expression;
 }
@@ -121,7 +127,7 @@ function containerToExpression(moduleMetadata, container, iterationContext) {
     const children = compositionsToArrayExpression(moduleMetadata, container.compositions, iterationContext) || t.arrayExpression([]);
     // If key or slot is specified, then the container will need to be
     // accounted for in the module via the element function.
-    if (container.key || container.slot) {
+    if (container.key || (container.slot && !container.isActive)) {
         const params = [];
         // arg1: Composition configuration.
         params.push(getCompositionConfig(container, undefined, iterationContext));
@@ -167,7 +173,9 @@ function composedAdgToExpression(moduleMetadata, composedAdg, iterationContext)
         throw new Error(common_shared_1.ERROR_PREFIX + 'binding not yet supported for ComposedAdg input');
     }
     // arg2: Composition configuration.
-    params.push(getCompositionConfig(composedAdg, componentId, iterationContext));
+    const dependentProps = new Set();
+    const config = getCompositionConfig(composedAdg, componentId, iterationContext, dependentProps);
+    params.push(config);
     // arg3: Context.
     params.push(types_1.ID.CONTEXT);
     // arg4: Array of expressions for each child.
@@ -175,6 +183,12 @@ function composedAdgToExpression(moduleMetadata, composedAdg, iterationContext)
     if (children && children.elements.length) {
         params.push(children);
     }
+    else {
+        params.push(t.arrayExpression());
+    }
+    // arg5: Array of dependent properties
+    const expArray = [...dependentProps].map((ele) => t.stringLiteral(ele));
+    params.push(t.arrayExpression(expArray));
     return t.callExpression(types_1.ID.COMPOSED_GRAPH_FUNC, params);
 }
 exports.composedAdgToExpression = composedAdgToExpression;
@@ -188,7 +202,13 @@ exports.composedAdgToExpression = composedAdgToExpression;
 function iterationToExpression(moduleMetadata, iteration, iterationContext = []) {
     const params = [];
     // arg1: Expression for the collection being iterated.
-    params.push((0, genericAstGeneration_1.bindingToExpression)(iteration.input, iterationContext));
+    const props = [
+        t.objectProperty(t.identifier('c'), (0, genericAstGeneration_1.valueReferenceToExpression)(moduleMetadata, iteration.input, iterationContext)),
+    ];
+    if (iteration.slot !== undefined) {
+        props.push(t.objectProperty(t.identifier('slot'), t.stringLiteral(iteration.slot)));
+    }
+    params.push(t.objectExpression(props));
     // arg2: Context.
     params.push(types_1.ID.CONTEXT);
     // arg3: Function to return compositions inside the the iteration.
@@ -233,33 +253,15 @@ exports.slotToExpression = slotToExpression;
  * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
  * @returns {Expression} the babel Expression representing the Image prompt into the Resolver API
  */
-function imageToExpression(image, iterationContext) {
+function imageToExpression(moduleMetadata, image, iterationContext) {
     const params = [];
-    const funcObjProps = [];
-    if ((0, common_shared_1.isCompositionAnImage)(image)) {
-        if ((0, common_shared_1.isSrcPrimitiveValue)(image.src)) {
-            // type guard ensures `image.src` is a PrimitiveValue
-            // lwc-platform will NOT produce an Image KomaciNode with a blank or missing src attribute.
-            // However, just in case we do encounter this, we handle it here by simply NOT producing the
-            // function ObjectProperty for such a node.
-            if (image.src.value &&
-                typeof image.src.value === 'string' &&
-                image.src.value !== '') {
-                funcObjProps.push(t.objectProperty(types_1.ID.IMG_SRC, t.stringLiteral(image.src.value)));
-            }
-        }
-        else if ((0, common_shared_1.isSrcABinding)(image.src)) {
-            // type guard ensures `image.src` is a Binding
-            // lwc-platform will NOT produce an Image KomaciNode with a blank or missing src attribute.
-            // However, just in case we do encounter this, we handle it here by simply NOT producing the
-            // function ObjectProperty for such a node.
-            if (image.src.value !== '') {
-                funcObjProps.push(t.objectProperty(types_1.ID.IMG_SRC, (0, genericAstGeneration_1.bindingToExpression)(image.src, iterationContext)));
-            }
-        }
+    if ((0, common_shared_1.isCompositionAnImage)(image) &&
+        image.src.value &&
+        typeof image.src.value === 'string' &&
+        image.src.value !== '') {
+        params.push(t.objectProperty(types_1.ID.IMG_SRC, (0, genericAstGeneration_1.valueReferenceToExpression)(moduleMetadata, image.src, iterationContext)));
     }
-    params.push(t.objectExpression(funcObjProps));
-    return t.callExpression(types_1.ID.IMG_FUNC, params);
+    return t.callExpression(types_1.ID.IMG_FUNC, [t.objectExpression(params), types_1.ID.CONTEXT]);
 }
 exports.imageToExpression = imageToExpression;
 /**
@@ -268,11 +270,12 @@ exports.imageToExpression = imageToExpression;
  * @param {ComposedAdg | Container | Slot} composition the Composition from which to create a configuration (as a ComposedAdg, Container, or Slot)
  * @param {string} componentId the component indentifier, as a string
  * @param {string[]} iterationContext if this is being called from inside an iteration we need that prepend context for bindingToExpression
+ * @param {t.Expression[]} dependentProps list of properties which are dependencies of this composition
  * @returns {ObjectExpression} the babel ObjectExpression representing the Resolver API CompositionConfig
  */
-function getCompositionConfig(composition, componentId, iterationContext) {
+function getCompositionConfig(composition, componentId, iterationContext, dependentProps) {
     const config = [];
-    if (composition.slot) {
+    if (composition.slot !== undefined) {
         config.push(t.objectProperty(types_1.ID.SLOT, t.stringLiteral(composition.slot)));
     }
     // ComposedAdg config contains additional information.
@@ -289,6 +292,11 @@ function getCompositionConfig(composition, componentId, iterationContext) {
                     props.push(t.objectProperty(hasSpecialCharacters.test(propName)
                         ? t.stringLiteral(propName)
                         : t.identifier(propName), (0, genericAstGeneration_1.bindingToExpression)(prop, iterationContext)));
+                    const propValue = prop.value.split('/')[0];
+                    // exclude iteration bindings from dependent prop list
+                    if (!iterationContext?.includes(propValue)) {
+                        dependentProps?.add(propValue);
+                    }
                 }
                 else if (prop.type === 'PrimitiveValue') {
                     props.push(t.objectProperty(hasSpecialCharacters.test(propName)
@@ -296,7 +304,7 @@ function getCompositionConfig(composition, componentId, iterationContext) {
                         : t.identifier(propName), (0, genericAstGeneration_1.primitiveToExpression)(prop)));
                 }
             }
-            config.push(t.objectProperty(types_1.ID.PROPS, t.objectExpression(props)));
+            config.push(t.objectProperty(types_1.ID.PROPS, t.arrowFunctionExpression([types_1.ID.CONTEXT], t.objectExpression(props))));
         }
     }
     return t.objectExpression(config);

package/build/functionAstGeneration.d.ts

@@ -92,4 +92,11 @@ export declare function produceErrorAdgFunction(moduleMetadata: ModuleMetadata,
  * @returns an expression statement, eg: adg0.meta = adg0meta
  */
 export declare function composeStaticMetadataAssignmentExpression(adgName: string, staticMetadataObject: t.VariableDeclaration): t.ExpressionStatement;
+/**
+ * Helper function to set self service as true. This way we can indicate at the resolver level what resolution
+ * flow to use
+ * @param adgName the name of the adg function to associate the adgMeta object with.
+ * @returns an expression statement, eg: adg0.self = true
+ */
+export declare function composeSelfServiceAssignmentExpression(adgName: string): t.ExpressionStatement;
 //# sourceMappingURL=functionAstGeneration.d.ts.map

package/build/functionAstGeneration.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.composeStaticMetadataAssignmentExpression = exports.produceErrorAdgFunction = exports.getInlineFunctionFromTemplateCompositions = exports.getAdgFunctionBody = exports.addExportStatement = exports.composeAdgStaticMetadata = exports.composeAdgFunction = exports.getFactoryFuncDeclaration = exports.adgToExpression = exports.sanitizeFunction = exports.hoistLocalFunction = void 0;
+exports.composeSelfServiceAssignmentExpression = exports.composeStaticMetadataAssignmentExpression = exports.produceErrorAdgFunction = exports.getInlineFunctionFromTemplateCompositions = exports.getAdgFunctionBody = exports.addExportStatement = exports.composeAdgStaticMetadata = exports.composeAdgFunction = exports.getFactoryFuncDeclaration = exports.adgToExpression = exports.sanitizeFunction = exports.hoistLocalFunction = void 0;
 const t = __importStar(require("@babel/types"));
 const common_shared_1 = require("@komaci/common-shared");
 const compositionAstGeneration_1 = require("./compositionAstGeneration");
@@ -307,19 +307,46 @@ function collectChildrenStaticMetadata(rootComposition, moduleMetadata) {
     const childrenArray = [];
     let imgFound = false;
     if (rootComposition) {
-        (0, common_shared_1.traverseComposition)(rootComposition, (comp) => {
-            if (comp.type == 'ComposedAdg' || comp.type == 'Image') {
-                if (comp.type == 'Image') {
-                    imgFound = true;
+        (0, common_shared_1.traverseComposition)(rootComposition, {
+            pretraversal: (comp) => {
+                if (comp.type == 'ComposedAdg' || comp.type == 'Image') {
+                    if (comp.type == 'Image') {
+                        imgFound = true;
+                    }
+                    const childProp = generateComposisitonMetadata(comp, moduleMetadata);
+                    childrenArray.push(childProp);
                 }
-                const childProp = generateComposisitonMetadata(comp, moduleMetadata);
-                childrenArray.push(childProp);
-            }
-            return false;
+                return false;
+            },
         });
     }
     return { childrenArray, imgFound };
 }
+/**
+ * Given a {@link ComposedAdg} and an {@link ObjectProperty} array, add the
+ * properties defined within that ADG. This function doesn't return anything, it
+ * adds the properties to the given propsArray.
+ *
+ * This function is used as part of the adg's static metadata.
+ * @param {ComposedAdg} comp adg to grab properties from
+ * @param {t.ObjectProperty[]} propsArray
+ */
+function addPropertyMetadata(comp, propsArray) {
+    if (comp.properties) {
+        const props = [];
+        for (const [key, value] of Object.entries(comp.properties)) {
+            //eg. creating -> type: "Binding"
+            const typeProp = t.objectProperty(t.identifier('type'), t.stringLiteral(value.type));
+            const stringValue = value.value != undefined ? value.value.toString() : 'undefined';
+            //eg. creating -> value: "input1"
+            const valueProp = t.objectProperty(t.identifier('value'), t.stringLiteral(stringValue));
+            const propObject = t.objectExpression([typeProp, valueProp]);
+            //eg creating -> prop1: {type: "", value: ""};
+            props.push(t.objectProperty(t.identifier(key), propObject));
+        }
+        propsArray.push(t.objectProperty(t.identifier('p'), t.objectExpression(props)));
+    }
+}
 /**
  * Function to generate a babel object expression based on the compisition type.
  * @param comp the compisition
@@ -339,19 +366,8 @@ function generateComposisitonMetadata(comp, moduleMetadata) {
                 }
             }
         }
-        if (comp.properties) {
-            const props = [];
-            for (const [key, value] of Object.entries(comp.properties)) {
-                //eg. creating -> type: "Binding"
-                const typeProp = t.objectProperty(t.identifier('type'), t.stringLiteral(value.type));
-                const stringValue = value.value != undefined ? value.value.toString() : 'undefined';
-                //eg. creating -> value: "input1"
-                const valueProp = t.objectProperty(t.identifier('value'), t.stringLiteral(stringValue));
-                const propObject = t.objectExpression([typeProp, valueProp]);
-                //eg creating -> prop1: {type: "", value: ""};
-                props.push(t.objectProperty(t.identifier(key), propObject));
-            }
-            propsArray.push(t.objectProperty(t.identifier('p'), t.objectExpression(props)));
+        if (moduleMetadata.includePropsMetadata) {
+            addPropertyMetadata(comp, propsArray);
         }
     }
     else if ((0, common_shared_1.isCompositionAnImage)(comp)) {
@@ -420,13 +436,17 @@ function getInlineFunctionFromTemplateCompositions(moduleMetadata, requiredFacto
     const statements = [];
     const body = t.blockStatement(statements);
     const emptyCompositionsArray = compositions.length < 1;
-    if (moduleMetadata.hasRenderFunction && adgMetadata.exportName == 'default') {
+    if (moduleMetadata.renderFunction && adgMetadata.exportName == 'default') {
         // function body destructured factory object. e.g. `const { cg } = fct;`
         const fctFuncs = getFactoryFuncDeclaration(requiredFactoryFunctions); // passing in false because we are not processing the script file in this method
         if (fctFuncs) {
             statements.push(fctFuncs);
         }
-        const rtFuncParams = [types_1.ID.HOISTED_RENDER_FUNC_ID, types_1.ID.CONTEXT];
+        const rtFuncParams = [
+            types_1.ID.HOISTED_RENDER_FUNC_ID,
+            types_1.ID.CONTEXT,
+            t.arrayExpression(moduleMetadata.renderFunction.requiredProperties.map((prop) => t.stringLiteral(prop))),
+        ];
         // rf(hoistedRenderFunction, CTX)
         const rtFunc = t.callExpression(types_1.ID.RENDER_FUNC, rtFuncParams);
         //creating the return statement
@@ -513,4 +533,14 @@ function composeStaticMetadataAssignmentExpression(adgName, staticMetadataObject
         .id.name)));
 }
 exports.composeStaticMetadataAssignmentExpression = composeStaticMetadataAssignmentExpression;
+/**
+ * Helper function to set self service as true. This way we can indicate at the resolver level what resolution
+ * flow to use
+ * @param adgName the name of the adg function to associate the adgMeta object with.
+ * @returns an expression statement, eg: adg0.self = true
+ */
+function composeSelfServiceAssignmentExpression(adgName) {
+    return t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(adgName), t.identifier('self')), t.booleanLiteral(true)));
+}
+exports.composeSelfServiceAssignmentExpression = composeSelfServiceAssignmentExpression;
 //# sourceMappingURL=functionAstGeneration.js.map

package/build/genericAstGeneration.d.ts

@@ -72,6 +72,22 @@ export declare function primitiveToExpression(primitive: PrimitiveValue): t.Expr
  * @returns A composed member expression
  */
 export declare function bindingToExpression(binding: Binding | PropertyReference, iterationContext?: string[], parseRootOnly?: boolean): t.Identifier | t.OptionalMemberExpression;
+/**
+ * compose a object that references a value for use in iteration and conditional factory functions.
+ * for times when we are operating inside of an iteration context, we want to leverage bindings so we can
+ * straight up hoist the iteration value. in every other use case we will be either a property reference or static value
+ *
+ * - t represent "type"
+ *  - t could be either `b` (binding) or `s` (static value)
+ * - v represents "value"
+ *  - maps to the value whatever that may be.
+ *
+ * @param moduleMetadata metadata about the module we are composing
+ * @param ref the value that needs to be referenced by this prop
+ * @param iterationContext if this value is based on some iteration
+ * @returns an object of the form { t: 'b' | 's', v: 'some value or prop ref' }
+ */
+export declare function valueReferenceToExpression(moduleMetadata: ModuleMetadata, ref: Binding | Value, iterationContext?: string[]): t.ObjectExpression;
 /**
  * Convert a single Komaci function to an object expression in the shape of a
  * FunctionDefinition as defined in Resolver API.

package/build/genericAstGeneration.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectMetadataForImportedTemplates = exports.exportNamedDeclarationForDynamicImport = exports.addUndefinedDefaultExport = exports.propertyToExpression = exports.functionToExpression = exports.bindingToExpression = exports.primitiveToExpression = exports.valueToExpression = exports.processWireFunctionType = exports.processErrorFunction = exports.addImportStatements = exports.generateResolvableModule = void 0;
+exports.collectMetadataForImportedTemplates = exports.exportNamedDeclarationForDynamicImport = exports.addUndefinedDefaultExport = exports.propertyToExpression = exports.functionToExpression = exports.valueReferenceToExpression = exports.bindingToExpression = exports.primitiveToExpression = exports.valueToExpression = exports.processWireFunctionType = exports.processErrorFunction = exports.addImportStatements = exports.generateResolvableModule = void 0;
 const common_shared_1 = require("@komaci/common-shared");
 const static_analyzer_1 = require("@komaci/static-analyzer");
 const t = __importStar(require("@babel/types"));
@@ -95,7 +95,7 @@ function generateResolvableModule(input, scriptKomaciDoc, templateKomaciDocMap,
             if (renderFunction) {
                 renderFunctionMetadata = (0, componentAstProcessing_1.processRenderFunction)(componentDefaultAdgIndex, moduleContext, moduleMetadata, renderFunction);
                 if (renderFunctionMetadata) {
-                    moduleMetadata.hasRenderFunction = true;
+                    moduleMetadata.renderFunction = renderFunctionMetadata;
                     moduleMetadata.adgs
                         .get(componentDefaultAdgIndex)
                         ?.requiredCompositionFactoryFunctions.add(common_shared_1.IdKeys.RENDER_FUNC);
@@ -104,7 +104,7 @@ function generateResolvableModule(input, scriptKomaciDoc, templateKomaciDocMap,
         }
     }
     //has a default html file but no render funciton ***
-    if (hasTemplateKomaciDoc && !moduleMetadata.hasRenderFunction) {
+    if (hasTemplateKomaciDoc && !moduleMetadata.renderFunction) {
         componentDefaultAdgIndex = (0, common_shared_1.reconcileDefaultAdg)(componentDefaultAdgIndex, moduleMetadata);
         if (componentDefaultAdgIndex !== undefined) {
             (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(defaultTemplateKomaciDoc, moduleMetadata, componentDefaultAdgIndex);
@@ -125,7 +125,7 @@ function generateResolvableModule(input, scriptKomaciDoc, templateKomaciDocMap,
     }
     //as long as we have at least one template and theres a valid render function, check to see if its imported. In the case the default html doc is imported, the assocated adg refernce will be set.
     if (Object.keys(moduleMetadata.templateKomaciDocMap).length > 0 &&
-        moduleMetadata.hasRenderFunction) {
+        moduleMetadata.renderFunction) {
         collectMetadataForImportedTemplates(moduleMetadata);
     }
     // all metadata collected at this point, time to start building ast
@@ -192,6 +192,9 @@ function generateResolvableModule(input, scriptKomaciDoc, templateKomaciDocMap,
             statements.push(staticMetadataObject);
             statements.push(adgFunctionDefinition);
             statements.push(staticMetadataAssignmentExpression);
+            // the default export is the only adg that we care to hook the self service thing to since default adgs are always what is passed to the resolver
+            const selfServiceAssignmentExpression = (0, functionAstGeneration_1.composeSelfServiceAssignmentExpression)(adg.defaultGeneratedName);
+            statements.push(selfServiceAssignmentExpression);
         }
         for (const [exportName, adg] of Object.entries(moduleMetadata.exports)) {
             statements.push((0, functionAstGeneration_1.addExportStatement)(adg.defaultGeneratedName, exportName));
@@ -543,6 +546,52 @@ function bindingToExpression(binding, iterationContext, parseRootOnly = false) {
     return expr;
 }
 exports.bindingToExpression = bindingToExpression;
+/**
+ * compose a object that references a value for use in iteration and conditional factory functions.
+ * for times when we are operating inside of an iteration context, we want to leverage bindings so we can
+ * straight up hoist the iteration value. in every other use case we will be either a property reference or static value
+ *
+ * - t represent "type"
+ *  - t could be either `b` (binding) or `s` (static value)
+ * - v represents "value"
+ *  - maps to the value whatever that may be.
+ *
+ * @param moduleMetadata metadata about the module we are composing
+ * @param ref the value that needs to be referenced by this prop
+ * @param iterationContext if this value is based on some iteration
+ * @returns an object of the form { t: 'b' | 's', v: 'some value or prop ref' }
+ */
+function valueReferenceToExpression(moduleMetadata, ref, iterationContext) {
+    let objectRef;
+    if (ref.type !== 'Binding' ||
+        (ref.type === 'Binding' &&
+            iterationContext &&
+            iterationContext.length !== 0 &&
+            iterationContext.includes(ref.value.split('/')[0]))) {
+        let objectValue;
+        if (ref.type === 'Binding') {
+            objectValue = bindingToExpression(ref, iterationContext);
+        }
+        else if (ref.value) {
+            objectValue = valueToExpression(ref, moduleMetadata);
+        }
+        else {
+            objectValue = t.identifier('undefined');
+        }
+        objectRef = t.objectExpression([
+            t.objectProperty(t.identifier('t'), t.stringLiteral('s')),
+            t.objectProperty(t.identifier('v'), objectValue),
+        ]);
+    }
+    else {
+        objectRef = t.objectExpression([
+            t.objectProperty(t.identifier('t'), t.stringLiteral('b')),
+            t.objectProperty(t.identifier('v'), t.stringLiteral(ref.value.replace(/\//g, '.'))),
+        ]);
+    }
+    return objectRef;
+}
+exports.valueReferenceToExpression = valueReferenceToExpression;
 /**
  * Convert a single Komaci function to an object expression in the shape of a
  * FunctionDefinition as defined in Resolver API.

package/build/types.js

@@ -70,6 +70,7 @@ exports.ID = {
     IMG_SRC: t.identifier('src'),
     IMG_FUNC: t.identifier('img'),
     HOISTED_RENDER_FUNC_ID: t.identifier('hoistedRender'),
+    CONDITION_FUNC: t.identifier('c'),
 };
 // enum representing the different states of the way an Import is used
 var ImportUsageState;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@komaci/esm-generator",
-    "version": "244.1.4",
+    "version": "244.1.7",
     "description": "Komaci generator for ADG ES modules",
     "homepage": "https://komaci.dev/",
     "repository": {
@@ -29,11 +29,11 @@
         "@babel/core": "^7.9.0",
         "@babel/generator": "^7.9.0",
         "@babel/types": "^7.9.0",
-        "@komaci/common-shared": "244.1.4",
-        "@komaci/static-analyzer": "244.1.4"
+        "@komaci/common-shared": "244.1.7",
+        "@komaci/static-analyzer": "244.1.7"
     },
     "devDependencies": {
-        "@komaci/types": "244.1.4",
+        "@komaci/types": "244.1.7",
         "@lwc-platform/sfdc-lwc-compiler": "242.15.1-2.28.0",
         "@lwc/metadata": "^2.28.0-0"
     }