@komaci/esm-generator 240.1.3

package/build/__tests__/templateStrings.spec.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const shared_1 = require("../shared");
+const common_shared_1 = require("@komaci/common-shared");
+const types_1 = require("@babel/types");
+describe('updateKomaciDocumentWithValidTemplatedStrings', () => {
+    it('should add info about templates to the functions array of the default adg', () => {
+        const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/assorted-template-strings');
+        const komaciDoc = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'script-komaci-doc.json'), {
+            encoding: 'utf-8',
+        }));
+        const src = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+            encoding: 'utf-8',
+        });
+        const ast = (0, common_shared_1.generateAstFromSrcCode)(src);
+        const { templateStrings } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+        const templateStringsInfo = [
+            {
+                template: templateStrings[0],
+                generatedName: 't0',
+                memberUsage: ['basicInit'],
+            },
+            {
+                template: templateStrings[1],
+                generatedName: 't1',
+                memberUsage: [],
+            },
+        ];
+        (0, shared_1.updateKomaciDocumentWithValidTemplatedStrings)(komaciDoc, templateStringsInfo);
+        expect(komaciDoc.adgs?.[0].functions).toHaveLength(3);
+        expect(komaciDoc.adgs?.[0].functions?.[1].type).toBe(shared_1.TEMPLATED_STRING_FUNCTION);
+        expect(komaciDoc.adgs?.[0].functions?.[1].reference.type).toBe('InternalReference');
+        expect(komaciDoc.adgs?.[0].functions?.[1].reference.value).toBe('t0');
+        expect(komaciDoc.adgs?.[0].functions?.[2].type).toBe(shared_1.TEMPLATED_STRING_FUNCTION);
+        expect(komaciDoc.adgs?.[0].functions?.[2].reference.type).toBe('InternalReference');
+        expect(komaciDoc.adgs?.[0].functions?.[2].reference.value).toBe('t1');
+    });
+});
+describe('hoistTemplateStrings', () => {
+    const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/assorted-template-strings');
+    const src = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+        encoding: 'utf-8',
+    });
+    const ast = (0, common_shared_1.generateAstFromSrcCode)(src);
+    const { templateStrings } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+    const templateStringsInfo = [
+        {
+            template: templateStrings[0],
+            generatedName: 't0',
+            memberUsage: ['basicInit'],
+        },
+        {
+            template: templateStrings[1],
+            generatedName: 't1',
+            memberUsage: [],
+        },
+    ];
+    const emptyProgram = (0, types_1.file)((0, types_1.program)([]));
+    const importReferencesMap = {
+        '1/names/0': {
+            localName: (0, types_1.identifier)('i1'),
+            resourceName: 'lightning/graphql',
+            importDeclaration: (0, types_1.importDeclaration)([(0, types_1.importSpecifier)((0, types_1.identifier)('i1'), (0, types_1.identifier)('gql'))], (0, types_1.stringLiteral)('lightning/graphql')),
+            importSpecifier: (0, types_1.importSpecifier)((0, types_1.identifier)('i1'), (0, types_1.identifier)('gql')),
+            exportName: undefined,
+            importUsages: new Set(),
+        },
+        '2/names/0': {
+            localName: (0, types_1.identifier)('i2'),
+            resourceName: 'snoop',
+            importDeclaration: (0, types_1.importDeclaration)([(0, types_1.importSpecifier)((0, types_1.identifier)('i2'), (0, types_1.identifier)('sneaky'))], (0, types_1.stringLiteral)('snoop')),
+            importSpecifier: (0, types_1.importSpecifier)((0, types_1.identifier)('i2'), (0, types_1.identifier)('sneaky')),
+            exportName: undefined,
+            importUsages: new Set(),
+        },
+    };
+    const definedImports = new Map();
+    definedImports.set('gql', {
+        isDefault: false,
+        isNamespaceSpecifier: false,
+        isSupported: true,
+        namespace: 'lightning/graphql',
+        identifierName: 'gql',
+    });
+    definedImports.set('sneaky', {
+        isDefault: false,
+        isNamespaceSpecifier: false,
+        isSupported: true,
+        namespace: 'snoop',
+        identifierName: 'sneaky',
+    });
+    (0, shared_1.hoistTemplateStrings)(emptyProgram, importReferencesMap, definedImports, templateStringsInfo);
+    it('can compose a template string for a public api prop', () => {
+        const firstFunction = emptyProgram.program.body[0];
+        expect(firstFunction.type).toBe('FunctionDeclaration');
+        expect(firstFunction.id.name).toBe('t0');
+        expect(firstFunction.body.body).toHaveLength(1);
+        expect(firstFunction.body.body[0].type).toBe('ReturnStatement');
+        expect(firstFunction.body.body[0]
+            .argument?.type).toBe('TemplateLiteral');
+        expect(firstFunction.body.body[0]
+            .argument.expressions).toHaveLength(2);
+        expect(firstFunction.body.body[0]
+            .argument.expressions[0].type).toBe('MemberExpression');
+        expect(firstFunction.body
+            .body[0].argument.expressions[0].object.name).toBe('props');
+        expect(firstFunction.body
+            .body[0].argument.expressions[0].property.name).toBe('basicInit');
+        expect(firstFunction.body.body[0]
+            .argument.expressions[1].type).toBe('Identifier');
+        expect(firstFunction.body
+            .body[0].argument.expressions[1].name).toBe('i2');
+    });
+    it('can compose a template string for an internal prop', () => {
+        const firstFunction = emptyProgram.program.body[1];
+        expect(firstFunction.type).toBe('FunctionDeclaration');
+        expect(firstFunction.id.name).toBe('t1');
+        expect(firstFunction.body.body).toHaveLength(1);
+        expect(firstFunction.body.body[0].type).toBe('ReturnStatement');
+        expect(firstFunction.body.body[0]
+            .argument?.type).toBe('TaggedTemplateExpression');
+        expect(firstFunction.body.body[0]
+            .argument.quasi.expressions).toHaveLength(1);
+        expect(firstFunction.body
+            .body[0].argument.tag.name).toBe('i1');
+    });
+});
+//# sourceMappingURL=templateStrings.spec.js.map

package/build/index.d.ts

@@ -0,0 +1,4 @@
+import { GeneratorInput } from './types';
+export { GeneratorInput } from './types';
+export declare function generateKomaciModule(input: GeneratorInput): string;
+//# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateKomaciModule = void 0;
+const generator_1 = __importDefault(require("@babel/generator"));
+const shared_1 = require("./shared");
+const modGenScript_1 = require("./modGenScript");
+const modGenTemplate_1 = require("./modGenTemplate");
+const t = __importStar(require("@babel/types"));
+// Generate a module adhering to the Komaci Runtime Format which is used
+// by the Komaci Resolution Engine to drive dependency resolution.
+function generateKomaciModule(input) {
+    // Initial state for this call to module generator.
+    const generatorState = {
+        input,
+        adgImportSuffix: 0,
+        importAliasSuffix: 0,
+        scriptGenState: {
+            importRefsMap: {},
+            requiredFactoryFunctions: new Set(),
+            importInfosForWireAdapter: new Set(),
+            primingAdapterImportDeclarations: [],
+        },
+        templateGenState: {
+            importRefsMap: {},
+            requiredFactoryFunctions: new Set(),
+            refProps: new Set(),
+        },
+        iterationContext: [],
+        defaultCompImported: false,
+        adgNameMap: {},
+        isDefaultExportFound: false,
+    };
+    try {
+        if (input.moduleInfo.type === 'file') {
+            // Determine file type based on extension in file name.
+            const segments = input.moduleInfo.fileName.split('.');
+            if (segments.length < 2) {
+                throw new Error(shared_1.ERROR_PREFIX + 'unable to determine file type');
+            }
+            const fileExt = segments[segments.length - 1];
+            let sourceFile;
+            if (fileExt === 'html') {
+                sourceFile = (0, modGenTemplate_1.generateTemplateModule)(generatorState, input.moduleInfo.komaciDoc);
+            }
+            else if (fileExt === 'js') {
+                sourceFile = (0, modGenScript_1.generateScriptModule)(generatorState, input.moduleInfo.komaciDoc);
+            }
+            else {
+                throw new Error(shared_1.ERROR_PREFIX + 'unsupported file extension: ' + fileExt);
+            }
+            const babelOutput = (0, generator_1.default)(sourceFile);
+            return babelOutput.code;
+        }
+        else if (input.moduleInfo.type === 'bundle') {
+            // code to process a bundle
+            let filename = '', fileExt;
+            const docMap = input.moduleInfo.files; // {'test.html' : KomaciDoc1, 'test.js' : KomaciDoc2}
+            const filesMap = {}; // {'html' : {'test.html' : KomaciDoc1}, 'js' : {'test.js' : KomaciDoc2 }}
+            let sourceFile;
+            for (const [fullFilename, komaciDoc] of Object.entries(docMap)) {
+                // Determine file type based on extension in file name.
+                const segments = fullFilename.split('.');
+                if (segments.length < 2) {
+                    throw new Error(shared_1.ERROR_PREFIX + 'unable to determine file type');
+                }
+                filename = segments[0]; // the filename, up to but not including, the file separator character
+                fileExt = segments[segments.length - 1]; // filename extension, not including the separator
+                if (filename !== input.moduleInfo.name) {
+                    continue; // ignore files whose name do not match moduleInfo.name
+                }
+                let filesObj = {};
+                // check for existing map entry in order to append to it
+                // to support multiple files per filetype in the future
+                if (filesMap[fileExt]) {
+                    filesObj = filesMap[fileExt];
+                }
+                filesObj[filename] = komaciDoc;
+                if (fileExt == 'html') {
+                    filesMap['html'] = filesObj;
+                }
+                else if (fileExt === 'js') {
+                    filesMap['js'] = filesObj;
+                }
+                else {
+                    throw new Error(shared_1.ERROR_PREFIX + 'unsupported file extension: ' + fileExt);
+                }
+            }
+            const komaciJSDoc = filesMap && filesMap['js'] && filesMap['js'][input.moduleInfo.name]
+                ? filesMap['js'][input.moduleInfo.name]
+                : {};
+            const komaciHTMLDoc = filesMap && filesMap['html'] && filesMap['html'][input.moduleInfo.name]
+                ? filesMap['html'][input.moduleInfo.name]
+                : {};
+            // eslint-disable-next-line prefer-const
+            sourceFile = (0, modGenScript_1.generateCombinedModule)(generatorState, komaciJSDoc, komaciHTMLDoc);
+            // Generate source from constructed AST.
+            const babelOutput = (0, generator_1.default)(sourceFile);
+            return babelOutput.code;
+        }
+        throw new Error(shared_1.ERROR_PREFIX + 'unrecognized input type');
+    }
+    catch (e) {
+        const babelOutput = (0, generator_1.default)(t.file((0, modGenScript_1.produceErrorAdgFunction)(generatorState, e)));
+        return babelOutput.code;
+    }
+}
+exports.generateKomaciModule = generateKomaciModule;
+//# sourceMappingURL=index.js.map

package/build/modGenScript.d.ts

@@ -0,0 +1,38 @@
+import * as t from '@babel/types';
+import { GeneratorState } from './types';
+import { KomaciDocument } from '@komaci/types';
+import { ConsumedImports } from '@komaci/common-shared';
+/**
+ * Generate the resolvable module for a single JS Script
+ * @param {GeneratorState} generatorState the state of the ESM generator
+ * @param {KomaciDocument} komaciDoc the KomaciDocument representation of the JS Script
+ * @returns {File} babel/types File representation of the entire JS Script. In other works, the Abstract systax tree
+ *          of the generated resolvable module.
+ */
+export declare function generateScriptModule(generatorState: GeneratorState, komaciDoc: KomaciDocument): t.File;
+/**
+ * Given information about what imports a getter consumes, we check the komaci doc to make sure all the
+ * import info is available
+ * @param komaciScriptDoc The Komaci doc to process
+ * @param consumedImports metadata about getter import consumption
+ */
+export declare function updateImportsWithGetterConsumption(komaciScriptDoc: KomaciDocument, consumedImports: ConsumedImports): void;
+/**
+ * Generates the resolvable runtime module for a script and template file.
+ * @param {GeneratorState} generatorState the state of the ESM generator
+ * @param {KomaciDocument} komaciScriptDoc the Komaci doc for the script file
+ * @param {KomaciDocument} komaciTemplateDoc the Komaci doc for the template file
+ * @returns babel/types File representing the generated, combined resolvable runtime module. In other words,
+ * the Abstract Syntax Tree of the combined, resolvable module.
+ */
+export declare function generateCombinedModule(generatorState: GeneratorState, komaciScriptDoc: KomaciDocument, komaciTemplateDoc: KomaciDocument): t.File;
+/**
+ * A barebones resolvable module default export with a singular node describing the context of an error.
+ *
+ * We return this instead of a real resolvable module if something throws an error during resolvable module generation
+ * @param generatorState The state of the generator for pass through to adgToExpression
+ * @param error The error that was thrown
+ * @returns A default export representing the error state for this resolvable module
+ */
+export declare function produceErrorAdgFunction(generatorState: GeneratorState, error: Error): t.Program;
+//# sourceMappingURL=modGenScript.d.ts.map