@sitecore-content-sdk/content 1.5.0-canary.5

package/dist/cjs/tools/codegen/import-map.js

@@ -0,0 +1,411 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.writeImportMap = exports.getImportValueAlias = exports.getImportedValues = exports.importUnitMocks = exports.defaultMapTemplate = exports.getImportMap = exports.unitMocks = void 0;
+const ts = __importStar(require("typescript"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const core_1 = require("@sitecore-content-sdk/core");
+const templating_1 = require("./../templating");
+const crypto_1 = __importDefault(require("crypto"));
+const utils_1 = require("./utils");
+let _getComponentList = templating_1.getComponentList;
+const aliasImport = /^([a-zA-Z0-9]+) as .+$/;
+const unitMocks = ({ getComponentListStub, }) => {
+    getComponentListStub && (_getComponentList = getComponentListStub);
+};
+exports.unitMocks = unitMocks;
+/**
+ * Gets a Map object with import modules and their respective exports present throughout the paths specified
+ * @param {string} paths paths to files to be processed for import-map
+ * @returns {Map<string, ImportModule>} collection of keys and values, where keys refer to modules being processed and values are collections of exports for each module
+ */
+exports.getImportMap = _getImportMap;
+/**
+ * Builds file contents for component map based on the default template
+ * @param {Map<string, ImportModule>} indexedImportMap map to be processed into final component-map.ts file
+ * @returns {string} file code for component-map.ts
+ * @internal
+ */
+exports.defaultMapTemplate = _defaultMapTemplate;
+exports.importUnitMocks = {
+    set getImportMap(mockImplementation) {
+        exports.getImportMap = mockImplementation;
+    },
+    get getImportMap() {
+        return _getImportMap;
+    },
+    set defaultMapTemplate(mockImplementation) {
+        exports.defaultMapTemplate = mockImplementation;
+    },
+    get defaultMapTemplate() {
+        return _defaultMapTemplate;
+    },
+};
+/**
+ * Parses and AST import node and extracts all imported values from it
+ * @param {ts.ImportDeclaration} importNode import node to be parsed
+ * @returns {ImportNames | null} object with named, default and namespace imported values, or null if import node is not valid
+ */
+const getImportedValues = (importNode) => {
+    const importClause = importNode.importClause;
+    if (!importClause) {
+        console.warn('Cannot parse import string from: %s', importNode.getText());
+        return null;
+    }
+    const result = {
+        named: [],
+        default: null,
+        namespace: null,
+    };
+    importClause.getChildren().forEach((child) => {
+        if (child.kind === ts.SyntaxKind.NamedImports) {
+            // import [...,]{a,b,c}
+            child.forEachChild((namedChild) => {
+                const importText = namedChild.getText().trim();
+                const aliasMatch = aliasImport.exec(importText);
+                result.named.push(aliasMatch ? aliasMatch[1] : importText);
+            });
+        }
+        else if (child.kind === ts.SyntaxKind.NamespaceImport) {
+            // * as coolName
+            result.namespace = child.getText().replace('* as ', '');
+        }
+        else if (child.kind === ts.SyntaxKind.Identifier) {
+            // import coolName
+            result.default = child.getText();
+        }
+    });
+    return result;
+};
+exports.getImportedValues = getImportedValues;
+// return alias-like name for an import value/variable name
+// this helps alleviate duplicate import names in import-map.ts
+const getImportValueAlias = (importValue, moduleName, importType) => {
+    if (process.env.IMPORT_ALIAS_STRATEGY === 'plain')
+        return importValue;
+    // Add extra uniqueness since the same alias can be used for different import types
+    const importTypeId = importType === 'named' ? 'n' : importType === 'default' ? 'd' : 'ns';
+    const suffix = crypto_1.default.hash('sha1', `${moduleName}_${importTypeId}`);
+    return `${importValue}_${suffix}`;
+};
+exports.getImportValueAlias = getImportValueAlias;
+// eslint-disable-next-line jsdoc/require-jsdoc
+function _getImportMap(paths) {
+    // make preparations for handling ts/js files
+    const appPath = process.cwd();
+    let cliCompilerOptions = {
+        baseUrl: appPath,
+        allowJs: true,
+        target: ts.ScriptTarget.ESNext,
+    };
+    const tsConfig = ts.readConfigFile(path_1.default.resolve(appPath, 'tsconfig.json'), ts.sys.readFile);
+    if (tsConfig.error) {
+        console.warn(`[Codegen] Error reading tsconfig.json from app root: ${tsConfig.error.messageText}`);
+    }
+    else {
+        cliCompilerOptions = Object.assign(Object.assign({}, tsConfig.config.compilerOptions), cliCompilerOptions);
+    }
+    const tsHost = ts.createCompilerHost(cliCompilerOptions, true);
+    // indexed version of import map - we will store and aggregate unique import paths and their imports here
+    const importMap = new Map();
+    // index to keep track of unique import values imported from different modules
+    // helps avoid duplicate import names in the final import-map.ts file
+    const importsList = [];
+    paths.forEach((codeFilePath) => {
+        const codeFileFullPath = path_1.default.isAbsolute(codeFilePath)
+            ? codeFilePath
+            : path_1.default.resolve(appPath, codeFilePath);
+        // attempt to parse current file to extract imports from
+        const tsCodeSource = tsHost.getSourceFile(codeFileFullPath, ts.ScriptTarget.Latest, (msg) => {
+            throw new Error(`[Codegen] Failed to parse ${codeFileFullPath}: ${msg}`);
+        });
+        if (!tsCodeSource)
+            throw ReferenceError(`[Codegen] Failed to find file ${codeFileFullPath}`);
+        // By transpiling the code from current file to JS we get rid of unused imports and the type imports
+        const jsCode = ts.transpileModule(tsCodeSource.getFullText(), {
+            compilerOptions: cliCompilerOptions,
+        });
+        // despite the name, ts.createSourceFile only creates SourceFile instance in runtime. Go figure ¯\_(ツ)_/¯
+        const jsCodeSource = ts.createSourceFile('code.js', jsCode.outputText, ts.ScriptTarget.ESNext, true);
+        // finally, we parse the final, trasformed js code and process import statements
+        ts.forEachChild(jsCodeSource, (childNode) => {
+            var _a;
+            if (ts.isImportDeclaration(childNode) && childNode.importClause) {
+                const imports = (0, exports.getImportedValues)(childNode);
+                if (!imports) {
+                    return;
+                }
+                // import path is extracted
+                const moduleName = childNode.moduleSpecifier.getText().replace(/['"]/g, '');
+                const resolvedModule = ts.nodeModuleNameResolver(moduleName, codeFileFullPath, cliCompilerOptions, tsHost);
+                // get import path and check if its import target exists
+                const resolvedImportPath = (_a = resolvedModule === null || resolvedModule === void 0 ? void 0 : resolvedModule.resolvedModule) === null || _a === void 0 ? void 0 : _a.resolvedFileName;
+                if (!resolvedImportPath) {
+                    console.warn('[Codegen] Could not resolve a file for import %s', moduleName);
+                    return;
+                }
+                let importModuleName;
+                if (resolvedImportPath.includes('node_modules') ||
+                    resolvedImportPath.endsWith('.d.ts') ||
+                    !(0, utils_1.toPosixPath)(resolvedImportPath).startsWith((0, utils_1.toPosixPath)(appPath) + '/')) {
+                    // if import path points to a file in local app - process import path to the file (i.e. ./myComponent)
+                    // if it points to node_modules or a file in monorepo - parse import path as dependency module name (i.e. React)
+                    // external dependency → keep as-is
+                    importModuleName = (0, utils_1.isNodeModuleImport)(moduleName)
+                        ? (0, utils_1.stripExtension)(moduleName)
+                        : (0, utils_1.getRelativeImportPath)(resolvedImportPath, appPath);
+                }
+                else {
+                    // local file
+                    importModuleName = (0, utils_1.isNodeModuleImport)(moduleName)
+                        ? (0, utils_1.stripExtension)(moduleName)
+                        : (0, utils_1.getRelativeImportPath)(resolvedImportPath, appPath);
+                }
+                // Set module import info in the map. If module import exists - add entries to existing entry
+                // Otherwise, add new entry
+                if (!importMap.has(importModuleName)) {
+                    importMap.set(importModuleName, {
+                        namedExports: new Map(),
+                        defaultExport: null,
+                        namespaceExport: null,
+                    });
+                }
+                const moduleEntry = importMap.get(importModuleName);
+                imports.named.forEach((importEntry) => {
+                    const sameModuleNamedAlready = moduleEntry.namedExports.has(importEntry);
+                    if (sameModuleNamedAlready) {
+                        return;
+                    }
+                    const nameTaken = importsList.includes(importEntry);
+                    const importValue = nameTaken
+                        ? (0, exports.getImportValueAlias)(importEntry, importModuleName, 'named')
+                        : importEntry;
+                    moduleEntry.namedExports.set(importEntry, importValue);
+                    importsList.push(importEntry);
+                });
+                if (imports.namespace) {
+                    const sameModuleNamedAlready = moduleEntry.namespaceExport;
+                    if (sameModuleNamedAlready) {
+                        return;
+                    }
+                    const nameTaken = importsList.includes(imports.namespace);
+                    const importValue = nameTaken
+                        ? (0, exports.getImportValueAlias)(imports.namespace, importModuleName, 'namespace')
+                        : imports.namespace;
+                    moduleEntry.namespaceExport = importValue;
+                    importsList.push(importValue);
+                }
+                if (imports.default) {
+                    const sameModuleNamedAlready = moduleEntry.defaultExport;
+                    if (sameModuleNamedAlready) {
+                        return;
+                    }
+                    const nameTaken = importsList.includes(imports.default);
+                    const importValue = nameTaken
+                        ? (0, exports.getImportValueAlias)(imports.default, importModuleName, 'default')
+                        : imports.default;
+                    moduleEntry.defaultExport = importValue;
+                    importsList.push(importValue);
+                }
+            }
+        });
+    });
+    return importMap;
+}
+const prepImportMaps = async (paths, separateMaps) => {
+    const importMapFileDefault = path_1.default.join(process.cwd(), '.sitecore', 'import-map.ts');
+    if (!separateMaps) {
+        return [{ map: (0, exports.getImportMap)(paths), path: importMapFileDefault }];
+    }
+    const appPath = process.cwd();
+    const serverPaths = [];
+    const clientPaths = [];
+    const importMapFileClient = path_1.default.join(process.cwd(), '.sitecore', 'import-map.client.ts');
+    const importMapFileServer = path_1.default.join(process.cwd(), '.sitecore', 'import-map.server.ts');
+    for (const componentPath of paths) {
+        const fullPath = path_1.default.isAbsolute(componentPath)
+            ? componentPath
+            : path_1.default.resolve(appPath, componentPath);
+        // read the start of the file that may be 'use client'
+        const firstLine = await new Promise((resolve) => {
+            let readBuffer = '';
+            const stream = fs_1.default.createReadStream(fullPath, { end: 12 });
+            stream
+                .on('data', async (chunk) => {
+                readBuffer += chunk.toString();
+            })
+                .on('close', () => resolve(readBuffer))
+                .on('error', () => resolve(''));
+        });
+        if (!firstLine)
+            continue;
+        if (firstLine.match(/['"]use client['"]/)) {
+            clientPaths.push(fullPath);
+        }
+        else {
+            serverPaths.push(fullPath);
+        }
+    }
+    return [
+        { map: (0, exports.getImportMap)(serverPaths), path: importMapFileServer },
+        { map: (0, exports.getImportMap)(clientPaths), path: importMapFileClient, isClient: true },
+    ];
+};
+/**
+ * Entry point function for generating import-map. Parses provided paths and outputs the modules and imports from those files into .sitecore/import-map.ts
+ * @param {WriteImportMapArgsInternal} args include/exclude paths settings to be processed for import-map, and the Sitecore configuration.
+ * @public
+ */
+const writeImportMap = (args) => {
+    return async ({ scConfig } = {}) => {
+        var _a;
+        const config = (_a = args.scConfig) !== null && _a !== void 0 ? _a : scConfig;
+        const defaultTemplate = args.serverTemplate || exports.defaultMapTemplate;
+        const clientTemplate = args.clientTemplate || exports.defaultMapTemplate;
+        if (!config) {
+            throw new Error('Sitecore configuration is required to be provided');
+        }
+        if (config.disableCodeGeneration) {
+            core_1.debug.common('Skipping import map generation. Code generation functionality is disabled.');
+            return;
+        }
+        const paths = _getComponentList(args.paths, args.exclude).map((entry) => entry.filePath);
+        // TODO: don't run in pages router
+        const importMaps = await prepImportMaps(paths, args.separateServerClientMaps);
+        for (const importMap of importMaps) {
+            console.log(`[Codegen] Generating import map: ${JSON.stringify({
+                paths: args.paths,
+                exclude: args.exclude,
+            })}.\n Writing into ${importMap.path} ...`);
+            // get generated map and combine with default one
+            // can be expanded when adding support for non-react frameworks
+            const importMapContent = importMap.isClient
+                ? clientTemplate(importMap.map)
+                : defaultTemplate(importMap.map);
+            try {
+                fs_1.default.writeFileSync(importMap.path, importMapContent, {
+                    encoding: 'utf8',
+                });
+            }
+            catch (error) {
+                console.error(`[Codegen] Import Map generation failed. Error writing to file ${importMap.path}:`, error);
+                throw error;
+            }
+        }
+    };
+};
+exports.writeImportMap = writeImportMap;
+// eslint-disable-next-line jsdoc/require-jsdoc
+function _defaultMapTemplate(indexedImportMap, framework = 'core') {
+    const importStatements = [];
+    const importMapArray = Array.from(indexedImportMap);
+    // get import map entries after
+    const finalImportMap = importMapArray.map(([modulePath, imports]) => {
+        const defaultExport = {
+            name: 'default',
+            value: imports.defaultExport,
+        };
+        const namedExports = Array.from(imports.namedExports).map(([name, value]) => {
+            return {
+                name,
+                value,
+            };
+        });
+        const namespaceExport = {
+            name: '*',
+            value: imports.namespaceExport,
+        };
+        return {
+            module: modulePath,
+            defaultExport,
+            namedExports,
+            namespaceExport,
+        };
+    });
+    finalImportMap.forEach((entry) => {
+        if (entry.namedExports.length > 0) {
+            const namedExports = entry.namedExports
+                .map((entry) => {
+                return entry.name !== entry.value ? `${entry.name} as ${entry.value}` : entry.name;
+            })
+                .join(', ');
+            importStatements.push(`import { ${namedExports} } from '${entry.module}';`);
+        }
+        if (entry.defaultExport.value) {
+            importStatements.push(`import ${entry.defaultExport.value} from '${entry.module}';`);
+        }
+        if (entry.namespaceExport.value) {
+            importStatements.push(`import * as ${entry.namespaceExport.value} from '${entry.module}';`);
+        }
+    });
+    const outputExportEntries = (entry) => {
+        return ([...entry.namedExports, entry.defaultExport, entry.namespaceExport]
+            .filter((entry) => entry.value !== null)
+            .map((namedExport) => `      { name: '${namedExport.name}', value: ${namedExport.value} }`)
+            .join(',\n') + ',');
+    };
+    return `// This file is auto-generated by the Sitecore Content SDK.
+// Below are built-in Content SDK imports neccessary for the import map
+import {
+  combineImportEntries,
+  defaultImportEntries,
+  ImportEntry,
+} from '@sitecore-content-sdk/${framework}/codegen';
+// end of built-in imports
+
+${importStatements.join('\n')}
+
+const importMap = [
+${finalImportMap
+        .map((entry) => [
+        '  {',
+        `    module: '${entry.module}',`,
+        '    exports: [',
+        outputExportEntries(entry),
+        '    ]',
+        '  }',
+    ]
+        .filter(Boolean)
+        .join('\n'))
+        .join(',\n')}
+] as ImportEntry[];
+
+export default combineImportEntries(defaultImportEntries, importMap);
+`;
+}