@komaci/esm-generator 240.1.3

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

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = __importDefault(require("glob"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("../index");
+const FIXTURES_DIR = path_1.default.join(__dirname, 'fixtures-combined-files');
+const INPUT_HTML_JSON_FILENAME = 'komaciHTMLDoc.json';
+const INPUT_JS_JSON_FILENAME = 'komaciJSDoc.json';
+const INPUT_SRC_FILE_JSON_FILENAME = 'actual.js';
+const INPUT_SRC_FILE_HTML_FILENAME = 'actual.html';
+const EXPECTED_JS_FILENAME = 'expected.src';
+function generateModuleSource(komaciHTMLDoc, komaciJSDoc, srcFileMap) {
+    const filesMap = {};
+    if (komaciHTMLDoc !== null) {
+        filesMap['test.html'] = komaciHTMLDoc;
+    }
+    if (komaciJSDoc !== null) {
+        filesMap['test.js'] = komaciJSDoc;
+    }
+    // adding miscellaneous files of empty Komaci docs, to test the negative case of unexpectedly named files
+    filesMap['something.js'] = {};
+    filesMap['somethingElese.html'] = {};
+    const input = {
+        moduleInfo: {
+            name: 'test',
+            namespace: 'c',
+            type: 'bundle',
+            files: filesMap,
+        },
+    };
+    input.srcFileMap = srcFileMap;
+    return (0, index_1.generateKomaciModule)(input);
+}
+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'));
+    for (const caseEntry of fixtures) {
+        const caseFolder = path_1.default.dirname(caseEntry);
+        const caseName = path_1.default.relative(FIXTURES_DIR, caseFolder);
+        const fixtureFilePath = (fileName) => {
+            return path_1.default.join(caseFolder, fileName);
+        };
+        const readFixtureFile = (fileName) => {
+            const filePath = fixtureFilePath(fileName);
+            return fs_1.default.existsSync(filePath) ? fs_1.default.readFileSync(filePath, 'utf-8') : null;
+        };
+        const writeFixtureFile = (fileName, content) => {
+            const filePath = fixtureFilePath(fileName);
+            fs_1.default.writeFileSync(filePath, content, { encoding: 'utf-8' });
+        };
+        it(`${caseName}`, () => {
+            const src1 = readFixtureFile(INPUT_HTML_JSON_FILENAME);
+            const src2 = readFixtureFile(INPUT_JS_JSON_FILENAME);
+            const srcFileMap = {};
+            srcFileMap['test.js'] = readFixtureFile(INPUT_SRC_FILE_JSON_FILENAME);
+            srcFileMap['test.html'] = readFixtureFile(INPUT_SRC_FILE_HTML_FILENAME);
+            const komaciHTMLDoc = JSON.parse(src1);
+            const komaciJSDoc = JSON.parse(src2);
+            const actualModuleSrc = generateModuleSource(komaciHTMLDoc, komaciJSDoc, srcFileMap);
+            let expectedModuleSrc = readFixtureFile(EXPECTED_JS_FILENAME);
+            if (expectedModuleSrc == null) {
+                // write file if doesn't exist (ie new fixture)
+                expectedModuleSrc = actualModuleSrc;
+                writeFixtureFile(EXPECTED_JS_FILENAME, expectedModuleSrc);
+            }
+            // check that the actual newly generated mod source matches expected
+            expect(actualModuleSrc).toEqual(expectedModuleSrc);
+        });
+    }
+});
+//# sourceMappingURL=komaci-bundle-module.fixtures.spec.js.map

package/build/__tests__/komaci-script-module.fixtures.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=komaci-script-module.fixtures.spec.d.ts.map

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

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = __importDefault(require("glob"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("../index");
+const FIXTURES_DIR = path_1.default.join(__dirname, 'fixtures-script-files');
+const INPUT_JSON_FILENAME = 'komaciDoc.json';
+const EXPECTED_JS_FILENAME = 'expected.src';
+function generateModuleSource(komaciDoc, actualSrc) {
+    const input = {
+        moduleInfo: {
+            name: 'test',
+            namespace: 'c',
+            type: 'file',
+            fileName: 'test.js',
+            komaciDoc,
+        },
+        srcFileMap: {
+            'test.css': 'p { text-align: center; }',
+            'test.html': '<html><body><h1>Hey</h1></body></html>',
+        },
+    };
+    if (actualSrc) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        input.srcFileMap['test.js'] = actualSrc;
+    }
+    return (0, index_1.generateKomaciModule)(input);
+}
+describe('fixtures', () => {
+    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);
+        const fixtureFilePath = (fileName) => {
+            return path_1.default.join(caseFolder, fileName);
+        };
+        const readFixtureFile = (fileName) => {
+            const filePath = fixtureFilePath(fileName);
+            return fs_1.default.existsSync(filePath)
+                ? fs_1.default.readFileSync(filePath, 'utf-8')
+                : undefined;
+        };
+        const writeFixtureFile = (fileName, content) => {
+            const filePath = fixtureFilePath(fileName);
+            fs_1.default.writeFileSync(filePath, content, { encoding: 'utf-8' });
+        };
+        it(`${caseName}`, () => {
+            const src = readFixtureFile(INPUT_JSON_FILENAME);
+            const komaciDoc = JSON.parse(src);
+            const actualModuleSrc = generateModuleSource(komaciDoc, readFixtureFile('actual.js'));
+            let expectedModuleSrc = readFixtureFile(EXPECTED_JS_FILENAME);
+            if (expectedModuleSrc === null) {
+                // write file if doesn't exist (ie new fixture)
+                expectedModuleSrc = actualModuleSrc;
+                writeFixtureFile(EXPECTED_JS_FILENAME, expectedModuleSrc);
+            }
+            // check that the actual newly generated mod source matches expected
+            expect(actualModuleSrc).toEqual(expectedModuleSrc);
+        });
+    }
+});
+//# sourceMappingURL=komaci-script-module.fixtures.spec.js.map

package/build/__tests__/komaci-template-module.fixtures.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=komaci-template-module.fixtures.spec.d.ts.map

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

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = __importDefault(require("glob"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("../index");
+const FIXTURES_DIR = path_1.default.join(__dirname, 'fixtures-template-files');
+const INPUT_JSON_FILENAME = 'komaciDoc.json';
+const EXPECTED_JS_FILENAME = 'expected.src';
+function generateModuleSource(komaciDoc) {
+    const input = {
+        moduleInfo: {
+            name: 'test',
+            namespace: 'c',
+            type: 'file',
+            fileName: 'test.html',
+            komaciDoc,
+        },
+    };
+    return (0, index_1.generateKomaciModule)(input);
+}
+describe('fixtures', () => {
+    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);
+        const fixtureFilePath = (fileName) => {
+            return path_1.default.join(caseFolder, fileName);
+        };
+        const readFixtureFile = (fileName) => {
+            const filePath = fixtureFilePath(fileName);
+            return fs_1.default.existsSync(filePath) ? fs_1.default.readFileSync(filePath, 'utf-8') : null;
+        };
+        const writeFixtureFile = (fileName, content) => {
+            const filePath = fixtureFilePath(fileName);
+            fs_1.default.writeFileSync(filePath, content, { encoding: 'utf-8' });
+        };
+        it(`${caseName}`, () => {
+            const src = readFixtureFile(INPUT_JSON_FILENAME);
+            const komaciDoc = JSON.parse(src);
+            const actualModuleSrc = generateModuleSource(komaciDoc);
+            let expectedModuleSrc = readFixtureFile(EXPECTED_JS_FILENAME);
+            if (expectedModuleSrc === null) {
+                // write file if doesn't exist (ie new fixture)
+                expectedModuleSrc = actualModuleSrc;
+                writeFixtureFile(EXPECTED_JS_FILENAME, expectedModuleSrc);
+            }
+            // check that the actual newly generated mod source matches expected
+            expect(actualModuleSrc).toEqual(expectedModuleSrc);
+        });
+    }
+});
+//# sourceMappingURL=komaci-template-module.fixtures.spec.js.map

package/build/__tests__/modGenScript.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=modGenScript.spec.d.ts.map

package/build/__tests__/modGenScript.spec.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const modGenScript_1 = require("../modGenScript");
+const generator_1 = __importDefault(require("@babel/generator"));
+const types_1 = require("@babel/types");
+const initGeneratorState = (input) => ({
+    input,
+    adgImportSuffix: 0,
+    importAliasSuffix: 0,
+    scriptGenState: {
+        importRefsMap: {},
+        requiredFactoryFunctions: new Set([]),
+        importInfosForWireAdapter: new Set([]),
+        primingAdapterImportDeclarations: [],
+    },
+    templateGenState: {
+        importRefsMap: {},
+        requiredFactoryFunctions: new Set(),
+        refProps: new Set(),
+    },
+    iterationContext: [],
+    defaultCompImported: true,
+    adgNameMap: {},
+    isDefaultExportFound: true,
+});
+describe('generateScriptModule', () => {
+    it('should not process items requiring the AST if the source is not provided', () => {
+        const komaciDoc = JSON.parse(fs_1.default.readFileSync((0, path_1.join)(__dirname, './fixtures-script-files/class-props/komaciDoc.json'), 'utf-8'));
+        const filesMap = {};
+        filesMap['test.js'] = komaciDoc;
+        const input = {
+            moduleInfo: {
+                name: 'test',
+                namespace: 'lightning',
+                type: 'bundle',
+                files: filesMap,
+            },
+            srcFileMap: {
+                'somethingElse.js': 'eval("bye")',
+                'test.css': 'p { text-align: center; }',
+                'test.html': '<html><body><h1>Hey</h1></body></html>',
+            },
+        };
+        const generatorState = initGeneratorState(input);
+        (0, modGenScript_1.generateScriptModule)(generatorState, komaciDoc);
+        expect(komaciDoc.adgs?.[0].functions?.find((f) => f.type === 'GetterFunction')).toBeUndefined();
+    });
+    it('should process items requiring ast if the source is provided', () => {
+        const src = fs_1.default.readFileSync((0, path_1.join)(__dirname, './fixtures-script-files/class-props/actual.js'), 'utf-8');
+        const komaciDoc = JSON.parse(fs_1.default.readFileSync((0, path_1.join)(__dirname, './fixtures-script-files/class-props/komaciDoc.json'), 'utf-8'));
+        const filesMap = {};
+        filesMap['test.js'] = komaciDoc;
+        const input = {
+            moduleInfo: {
+                name: 'test',
+                namespace: 'lightning',
+                type: 'bundle',
+                files: filesMap,
+            },
+            srcFileMap: {
+                'test.js': src,
+                'test.css': 'p { text-align: center; }',
+                'test.html': '<html><body><h1>Hey</h1></body></html>',
+            },
+        };
+        const generatorState = initGeneratorState(input);
+        (0, modGenScript_1.generateScriptModule)(generatorState, komaciDoc);
+        expect(komaciDoc.adgs?.[0].functions?.find((f) => f.type === 'GetterFunction')).not.toBeUndefined();
+    });
+});
+describe('produceErrorAdgFunction', () => {
+    it('should produce a resolvable module with an adg with only one node that shows what the error was', () => {
+        const input = {
+            moduleInfo: {
+                name: 'test',
+                namespace: 'lightning',
+                type: 'bundle',
+                files: {},
+            },
+            srcFileMap: {
+                'test.js': '',
+                'test.css': 'p { text-align: center; }',
+                'test.html': '<html><body><h1>Hey</h1></body></html>',
+            },
+        };
+        const generatorState = initGeneratorState(input);
+        const expected = `export default function (fct, ctx) {
+  const {
+    adg
+  } = fct;
+  return adg(undefined, {}, [{
+    t: "ErrorFunction",
+    c: {
+      "error": "something bad happened",
+      "stack": "full stack normally"
+    }
+  }], comp1, []);
+}`;
+        const testError = new Error('something bad happened');
+        testError.stack = 'full stack normally';
+        const res = (0, modGenScript_1.produceErrorAdgFunction)(generatorState, testError);
+        expect((0, generator_1.default)((0, types_1.file)(res)).code).toBe(expected);
+    });
+});
+//# sourceMappingURL=modGenScript.spec.js.map

package/build/__tests__/modGenTemplate.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=modGenTemplate.spec.d.ts.map

package/build/__tests__/modGenTemplate.spec.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modGenTemplate_1 = require("../modGenTemplate");
+const types_1 = require("@babel/types");
+const shared_1 = require("../shared");
+const initGeneratorState = (input) => ({
+    input,
+    adgImportSuffix: 0,
+    importAliasSuffix: 0,
+    scriptGenState: {
+        importRefsMap: {},
+        requiredFactoryFunctions: new Set([]),
+        importInfosForWireAdapter: new Set([]),
+        primingAdapterImportDeclarations: [],
+    },
+    templateGenState: {
+        importRefsMap: {},
+        requiredFactoryFunctions: new Set(),
+        refProps: new Set(),
+    },
+    iterationContext: [],
+    defaultCompImported: true,
+    adgNameMap: {},
+    isDefaultExportFound: true,
+});
+const generatorInput = {
+    moduleInfo: {
+        name: 'test',
+        namespace: 'lightning',
+        komaciDoc: {},
+        fileName: 'test.html',
+        type: 'file',
+    },
+};
+describe('imageToExpression', () => {
+    it('should return an expression for a KomaciDocument Image node', () => {
+        const komaciDocImagePrimitive = {
+            type: 'Image',
+            src: {
+                type: 'PrimitiveValue',
+                value: 'testPrimitive.jpg', // this is string literal of a relative URL
+            },
+        };
+        const generatorState = initGeneratorState(generatorInput);
+        let expression = (0, modGenTemplate_1.imageToExpression)(generatorState, komaciDocImagePrimitive);
+        expect(expression.type).toBe('CallExpression');
+        let callExpression = expression;
+        expect(callExpression).not.toBeUndefined();
+        expect(callExpression.callee).toBe(shared_1.ID.IMG_FUNC);
+        expect(callExpression.arguments).not.toBeUndefined();
+        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments[0]).not.toBeUndefined();
+        expect(callExpression.arguments[0].type).toBe('ObjectExpression');
+        let objExpression = callExpression
+            .arguments[0];
+        expect(objExpression.properties).not.toBeUndefined();
+        expect(objExpression.properties).toHaveLength(1);
+        expect(objExpression.properties[0].type).toBe('ObjectProperty');
+        let objProperty = objExpression.properties[0];
+        expect(objProperty.key).toBe(shared_1.ID.IMG_SRC);
+        expect(objProperty.value).toEqual((0, types_1.stringLiteral)('testPrimitive.jpg')); // img({src: "testPrimitive.jpg"})
+        const komaciDocImageBinding = {
+            type: 'Image',
+            src: {
+                type: 'Binding',
+                value: 'testBinding', // this is a string literal, but represents a variable name
+            },
+        };
+        expression = (0, modGenTemplate_1.imageToExpression)(generatorState, komaciDocImageBinding);
+        expect(expression.type).toBe('CallExpression');
+        callExpression = expression;
+        expect(callExpression).not.toBeUndefined();
+        expect(callExpression.callee).toBe(shared_1.ID.IMG_FUNC);
+        expect(callExpression.arguments).not.toBeUndefined();
+        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments[0]).not.toBeUndefined();
+        expect(callExpression.arguments[0].type).toBe('ObjectExpression');
+        objExpression = callExpression.arguments[0];
+        expect(objExpression).not.toBeUndefined();
+        expect(objExpression.properties).not.toBeUndefined();
+        expect(objExpression.properties).toHaveLength(1);
+        expect(objExpression.properties[0].type).toBe('ObjectProperty');
+        objProperty = objExpression.properties[0];
+        expect(objProperty.key).toBe(shared_1.ID.IMG_SRC);
+        let 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})
+        const komaciDocImageNestedBinding = {
+            type: 'Image',
+            src: {
+                type: 'Binding',
+                value: 'imageObject/nested/imageName', // this is a string literal, represents nested-scoped variable names
+            },
+        };
+        expression = (0, modGenTemplate_1.imageToExpression)(generatorState, komaciDocImageNestedBinding);
+        expect(expression.type).toBe('CallExpression');
+        callExpression = expression;
+        expect(callExpression).not.toBeUndefined();
+        expect(callExpression.callee).toBe(shared_1.ID.IMG_FUNC);
+        expect(callExpression.arguments).not.toBeUndefined();
+        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments[0]).not.toBeUndefined();
+        expect(callExpression.arguments[0].type).toBe('ObjectExpression');
+        objExpression = callExpression.arguments[0];
+        expect(objExpression).not.toBeUndefined();
+        expect(objExpression.properties).not.toBeUndefined();
+        expect(objExpression.properties).toHaveLength(1);
+        expect(objExpression.properties[0].type).toBe('ObjectProperty');
+        objProperty = objExpression.properties[0];
+        expect(objProperty.key).toBe(shared_1.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})
+    });
+    it('should not return an expression for invalid KomaciDocument Image nodes due to invalid src.value type (boolean)', () => {
+        const komaciDocImagePrimitive = {
+            type: 'Image',
+            src: {
+                type: 'PrimitiveValue',
+                value: false, // not a supported type (boolean)
+            },
+        };
+        const generatorState = initGeneratorState(generatorInput);
+        const expression = (0, modGenTemplate_1.imageToExpression)(generatorState, komaciDocImagePrimitive);
+        expect(expression.type).toBe('CallExpression');
+        const callExpression = expression;
+        expect(callExpression).not.toBeUndefined();
+        expect(callExpression.callee).not.toBeUndefined();
+        expect(callExpression.callee).toBe(shared_1.ID.IMG_FUNC);
+        expect(callExpression.arguments).not.toBeUndefined();
+        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments[0].type).toBe('ObjectExpression');
+        const objExpression = callExpression
+            .arguments[0];
+        expect(objExpression.properties).not.toBeUndefined();
+        expect(objExpression.properties).toHaveLength(0); // no img() populated with a valid src attribute
+    });
+    it('should not return an expression for invalid KomaciDocument Image nodes due to blank src.value', () => {
+        const komaciDocImagePrimitiveBlank = {
+            type: 'Image',
+            src: {
+                type: 'PrimitiveValue',
+                value: '', // blanks not supported
+            },
+        };
+        const generatorState = initGeneratorState(generatorInput);
+        let expression = (0, modGenTemplate_1.imageToExpression)(generatorState, komaciDocImagePrimitiveBlank);
+        expression = (0, modGenTemplate_1.imageToExpression)(generatorState, komaciDocImagePrimitiveBlank);
+        expect(expression.type).toBe('CallExpression');
+        const callExpression = expression;
+        expect(callExpression).not.toBeUndefined();
+        expect(callExpression.callee).not.toBeUndefined();
+        expect(callExpression.callee).toBe(shared_1.ID.IMG_FUNC);
+        expect(callExpression.arguments).not.toBeUndefined();
+        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments[0].type).toBe('ObjectExpression');
+        const objExpression = callExpression
+            .arguments[0];
+        expect(objExpression.properties).not.toBeUndefined();
+        expect(objExpression.properties).toHaveLength(0); // no img() populated with a valid src attribute
+    });
+    it('should not return an expression for invalid KomaciDocument Image nodes with src.type that is neither Binding nor PrimitiveType', () => {
+        const komaciDocImageInvalidSrcValType = {
+            type: 'Image',
+            src: {
+                type: 'PrimitiveValue',
+                value: 'some random string',
+            },
+        };
+        const generatorState = initGeneratorState(generatorInput);
+        // change the src.value type to something invalid, a number
+        komaciDocImageInvalidSrcValType.src.value = 12345;
+        let expression = (0, modGenTemplate_1.imageToExpression)(generatorState, komaciDocImageInvalidSrcValType);
+        expression = (0, modGenTemplate_1.imageToExpression)(generatorState, komaciDocImageInvalidSrcValType);
+        expect(expression.type).toBe('CallExpression');
+        const callExpression = expression;
+        expect(callExpression).not.toBeUndefined();
+        expect(callExpression.callee).not.toBeUndefined();
+        expect(callExpression.callee).toBe(shared_1.ID.IMG_FUNC);
+        expect(callExpression.arguments).not.toBeUndefined();
+        expect(callExpression.arguments).toHaveLength(1);
+        expect(callExpression.arguments[0].type).toBe('ObjectExpression');
+        const objExpression = callExpression
+            .arguments[0];
+        expect(objExpression.properties).not.toBeUndefined();
+        expect(objExpression.properties).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=modGenTemplate.spec.js.map

package/build/__tests__/shared.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shared.spec.d.ts.map

package/build/__tests__/shared.spec.js

@@ -0,0 +1,62 @@
+"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 });
+const common_shared_1 = require("@komaci/common-shared");
+const shared_1 = require("../shared");
+const badImportRef_1 = require("./fixtures-source-code/badImportRef");
+const t = __importStar(require("@babel/types"));
+const generator_1 = __importDefault(require("@babel/generator"));
+describe('sanitizeFunction', () => {
+    const ast = (0, common_shared_1.generateAstFromSrcCode)(badImportRef_1.sourceClass);
+    const { getters } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+    const imports = new Map();
+    imports.set('test', {
+        identifierName: 'test',
+        namespace: 'force/shared',
+        isSupported: true,
+        isDefault: true,
+        isNamespaceSpecifier: false,
+    });
+    imports.set('bad', {
+        identifierName: 'test',
+        namespace: 'invalid/import',
+        isSupported: false,
+        isDefault: true,
+        isNamespaceSpecifier: false,
+    });
+    const generatedNameMap = new Map();
+    generatedNameMap.set('force/shared', 'i0');
+    generatedNameMap.set('invalid/import', shared_1.UNRESOLVED);
+    it('should be able to clean up and hoist a function with valid import references', () => {
+        (0, shared_1.sanitizeFunction)(getters[0], imports, generatedNameMap);
+        const hoisted = t.functionDeclaration(t.identifier('g0'), [t.identifier('props')], // make 'props' an input parameter to the hoisted getter
+        getters[0].node.body);
+        const generatedFunction = (0, generator_1.default)(t.file(t.program([hoisted])));
+        expect(generatedFunction.code).toBe(badImportRef_1.expectedGoodHoist);
+    });
+    it('should throw an error if we try to reference a bad input', () => {
+        expect(() => (0, shared_1.sanitizeFunction)(getters[1], imports, generatedNameMap)).toThrowError(new Error(`${shared_1.ERROR_PREFIX}: 'bad' does not map to valid import`));
+    });
+});
+//# sourceMappingURL=shared.spec.js.map

package/build/__tests__/templateStrings.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=templateStrings.spec.d.ts.map