@sitecore-content-sdk/core 1.3.0-canary.9 → 1.4.0-canary.2

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

@@ -1,316 +1,368 @@
-import * as ts from 'typescript';
-import path from 'path';
-import fs from 'fs';
-import { getComponentList } from './../templating';
-import debug from './../../debug';
-import crypto from 'crypto';
-import { isNodeModuleImport, stripExtension, getRelativeImportPath, toPosixPath } from './utils';
-let _getComponentList = getComponentList;
-const aliasImport = /^([a-zA-Z0-9]+) as .+$/;
-export const unitMocks = ({ getComponentListStub, }) => {
-    getComponentListStub && (_getComponentList = getComponentListStub);
-};
-/**
- * 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
- */
-export let 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
- */
-export let nextJsMapTemplate = _nextJsMapTemplate;
-export const importUnitMocks = {
-    set getImportMap(mockImplementation) {
-        getImportMap = mockImplementation;
-    },
-    get getImportMap() {
-        return _getImportMap;
-    },
-    set nextJsMapTemplate(mockImplementation) {
-        nextJsMapTemplate = mockImplementation;
-    },
-    get nextJsMapTemplate() {
-        return _nextJsMapTemplate;
-    },
-};
-/**
- * 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
- */
-export 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;
-};
-// return alias-like name for an import value/variable name
-// this helps alleviate duplicate import names in import-map.ts
-export 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.hash('sha1', `${moduleName}_${importTypeId}`);
-    return `${importValue}_${suffix}`;
-};
-// 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.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.isAbsolute(codeFilePath)
-            ? codeFilePath
-            : path.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 = 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') ||
-                    !toPosixPath(resolvedImportPath).startsWith(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 = isNodeModuleImport(moduleName)
-                        ? stripExtension(moduleName)
-                        : getRelativeImportPath(resolvedImportPath, appPath);
-                }
-                else {
-                    // local file
-                    importModuleName = isNodeModuleImport(moduleName)
-                        ? stripExtension(moduleName)
-                        : 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
-                        ? 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
-                        ? 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
-                        ? getImportValueAlias(imports.default, importModuleName, 'default')
-                        : imports.default;
-                    moduleEntry.defaultExport = importValue;
-                    importsList.push(importValue);
-                }
-            }
-        });
-    });
-    return importMap;
-}
-/**
- * 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 {WriteImportMapArgs} args include/exclude paths settings to be processed for import-map, and the Sitecore configuration
- */
-export const writeImportMap = (args) => {
-    return async ({ scConfig } = {}) => {
-        var _a;
-        const config = (_a = args.scConfig) !== null && _a !== void 0 ? _a : scConfig;
-        if (!config) {
-            throw new Error('Sitecore configuration is required to be provided');
-        }
-        if (config.disableCodeGeneration) {
-            debug.common('Skipping import map generation. Code generation functionality is disabled.');
-            return;
-        }
-        const paths = _getComponentList(args.paths, args.exclude).map((entry) => entry.filePath);
-        const importMapFile = path.join(process.cwd(), '.sitecore', 'import-map.ts');
-        console.log(`[Codegen] Generating import map: ${JSON.stringify({
-            paths: args.paths,
-            exclude: args.exclude,
-        })}.\n Writing into ${importMapFile} ...`);
-        // get generated map and combine with default one
-        const importMap = getImportMap(paths);
-        const importMapContent = nextJsMapTemplate(importMap);
-        try {
-            fs.writeFileSync(importMapFile, importMapContent, {
-                encoding: 'utf8',
-            });
-        }
-        catch (error) {
-            console.error(`[Codegen] Import Map generation failed. Error writing to file ${importMapFile}:`, error);
-            throw error;
-        }
-    };
-};
-// eslint-disable-next-line jsdoc/require-jsdoc
-function _nextJsMapTemplate(indexedImportMap) {
-    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') + ',');
-    };
-    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}';`);
-        }
-    });
+import * as ts from 'typescript';
+import path from 'path';
+import fs from 'fs';
+import { getComponentList } from './../templating';
+import debug from './../../debug';
+import crypto from 'crypto';
+import { isNodeModuleImport, stripExtension, getRelativeImportPath, toPosixPath } from './utils';
+let _getComponentList = getComponentList;
+const aliasImport = /^([a-zA-Z0-9]+) as .+$/;
+export const unitMocks = ({ getComponentListStub, }) => {
+    getComponentListStub && (_getComponentList = getComponentListStub);
+};
+/**
+ * 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
+ */
+export let 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
+ */
+export let defaultMapTemplate = _defaultMapTemplate;
+export const importUnitMocks = {
+    set getImportMap(mockImplementation) {
+        getImportMap = mockImplementation;
+    },
+    get getImportMap() {
+        return _getImportMap;
+    },
+    set defaultMapTemplate(mockImplementation) {
+        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
+ */
+export 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;
+};
+// return alias-like name for an import value/variable name
+// this helps alleviate duplicate import names in import-map.ts
+export 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.hash('sha1', `${moduleName}_${importTypeId}`);
+    return `${importValue}_${suffix}`;
+};
+// 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.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.isAbsolute(codeFilePath)
+            ? codeFilePath
+            : path.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 = 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') ||
+                    !toPosixPath(resolvedImportPath).startsWith(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 = isNodeModuleImport(moduleName)
+                        ? stripExtension(moduleName)
+                        : getRelativeImportPath(resolvedImportPath, appPath);
+                }
+                else {
+                    // local file
+                    importModuleName = isNodeModuleImport(moduleName)
+                        ? stripExtension(moduleName)
+                        : 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
+                        ? 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
+                        ? 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
+                        ? getImportValueAlias(imports.default, importModuleName, 'default')
+                        : imports.default;
+                    moduleEntry.defaultExport = importValue;
+                    importsList.push(importValue);
+                }
+            }
+        });
+    });
+    return importMap;
+}
+const prepImportMaps = async (paths, separateMaps) => {
+    const importMapFileDefault = path.join(process.cwd(), '.sitecore', 'import-map.ts');
+    if (!separateMaps) {
+        return [{ map: getImportMap(paths), path: importMapFileDefault }];
+    }
+    const appPath = process.cwd();
+    const serverPaths = [];
+    const clientPaths = [];
+    const importMapFileClient = path.join(process.cwd(), '.sitecore', 'import-map.client.ts');
+    const importMapFileServer = path.join(process.cwd(), '.sitecore', 'import-map.server.ts');
+    for (const componentPath of paths) {
+        const fullPath = path.isAbsolute(componentPath)
+            ? componentPath
+            : path.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.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: getImportMap(serverPaths), path: importMapFileServer },
+        { map: 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
+ */
+export const writeImportMap = (args) => {
+    return async ({ scConfig } = {}) => {
+        var _a;
+        const config = (_a = args.scConfig) !== null && _a !== void 0 ? _a : scConfig;
+        const defaultTemplate = args.serverTemplate || defaultMapTemplate;
+        const clientTemplate = args.clientTemplate || defaultMapTemplate;
+        if (!config) {
+            throw new Error('Sitecore configuration is required to be provided');
+        }
+        if (config.disableCodeGeneration) {
+            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.writeFileSync(importMap.path, importMapContent, {
+                    encoding: 'utf8',
+                });
+            }
+            catch (error) {
+                console.error(`[Codegen] Import Map generation failed. Error writing to file ${importMap.path}:`, error);
+                throw error;
+            }
+        }
+    };
+};
+// 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 } from '@sitecore-content-sdk/nextjs/codegen';
+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'))
+${finalImportMap
+        .map((entry) => [
+        '  {',
+        `    module: '${entry.module}',`,
+        '    exports: [',
+        outputExportEntries(entry),
+        '    ]',
+        '  }',
+    ]
+        .filter(Boolean)
+        .join('\n'))
         .join(',\n')}
-];
+] as ImportEntry[];
 
 export default combineImportEntries(defaultImportEntries, importMap);
-`;
-}
+`;
+}