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

package/dist/esm/tools/generate-map.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/esm/tools/generateMetadata.js

@@ -1,28 +1,29 @@
-import fs from 'fs';
-import path from 'path';
-import { getMetadata } from '../editing/metadata';
-import { ensurePathExists } from '../utils/ensurePath';
-/**
- * Generate application metadata
- * @param {GenerateMetadataConfig} config - Optional configuration for generating metadata.
- * If not provided, the default '.sitecore/metadata.json' will be used and allowWorkspaces will be set to false.
- * @returns {Promise<void>} A promise that resolves when the metadata generation is complete.
- */
-export const generateMetadata = (config) => {
-    return async () => {
-        var _a;
-        const metadata = getMetadata(!!(config === null || config === void 0 ? void 0 : config.allowWorkspaces));
-        writeMetadata(metadata, (_a = config === null || config === void 0 ? void 0 : config.destinationPath) !== null && _a !== void 0 ? _a : '.sitecore/metadata.json');
-    };
-};
-/**
- * Writes the metadata object to disk.
- * @param {Metadata} metadata metadata to write.
- * @param {string} destinationPath path to write the metadata to.
- */
-function writeMetadata(metadata, destinationPath) {
-    const filePath = path.resolve(destinationPath);
-    ensurePathExists(filePath);
-    console.log(`Writing metadata to ${filePath}`);
-    fs.writeFileSync(filePath, JSON.stringify(metadata, null, 2), { encoding: 'utf8' });
-}
+import fs from 'fs';
+import path from 'path';
+import { getMetadata } from '../editing/metadata';
+import { ensurePathExists } from '../utils/ensurePath';
+/**
+ * Generate application metadata
+ * @param {GenerateMetadataConfig} config - Optional configuration for generating metadata.
+ * If not provided, the default '.sitecore/metadata.json' will be used and allowWorkspaces will be set to false.
+ * @returns {Promise<void>} A promise that resolves when the metadata generation is complete.
+ * @public
+ */
+export const generateMetadata = (config) => {
+    return async () => {
+        var _a;
+        const metadata = getMetadata(!!(config === null || config === void 0 ? void 0 : config.allowWorkspaces));
+        writeMetadata(metadata, (_a = config === null || config === void 0 ? void 0 : config.destinationPath) !== null && _a !== void 0 ? _a : '.sitecore/metadata.json');
+    };
+};
+/**
+ * Writes the metadata object to disk.
+ * @param {Metadata} metadata metadata to write.
+ * @param {string} destinationPath path to write the metadata to.
+ */
+function writeMetadata(metadata, destinationPath) {
+    const filePath = path.resolve(destinationPath);
+    ensurePathExists(filePath);
+    console.log(`Writing metadata to ${filePath}`);
+    fs.writeFileSync(filePath, JSON.stringify(metadata, null, 2), { encoding: 'utf8' });
+}

package/dist/esm/tools/generateSites.js

@@ -1,51 +1,52 @@
-import path from 'path';
-import chalk from 'chalk';
-import fs from 'fs';
-import debug from '../debug';
-import { SiteInfoService } from '../site';
-import { ensurePathExists } from '../utils/ensurePath';
-import { createGraphQLClientFactory } from '../client';
-const DEFAULT_SITES_DIST_PATH = '.sitecore/sites.json';
-/**
- * Generates site information and writes it to a specified destination path.
- * @param {GenerateSitesConfig} config - The configuration for generating site info.
- * @returns {Promise<Function>} - A promise that resolves to an asynchronous function that fetches site information and writes it to a file.
- */
-export const generateSites = ({ scConfig: deprecatedScConfig, destinationPath, } = {}) => {
-    return async ({ scConfig } = {}) => {
-        const config = deprecatedScConfig !== null && deprecatedScConfig !== void 0 ? deprecatedScConfig : scConfig;
-        if (!config) {
-            throw new Error('Sitecore configuration is required to be provided');
-        }
-        let sites = [];
-        const sitesFilePath = path.resolve(destinationPath !== null && destinationPath !== void 0 ? destinationPath : DEFAULT_SITES_DIST_PATH);
-        debug.multisite(config.multisite.enabled
-            ? 'Multisite Enabled: Generating site information'
-            : 'Multisite Disabled');
-        if (config.multisite.enabled) {
-            try {
-                const siteInfoService = new SiteInfoService({
-                    clientFactory: createGraphQLClientFactory({
-                        api: config.api,
-                        retries: config.retries.count,
-                        retryStrategy: config.retries.retryStrategy,
-                    }),
-                });
-                sites = await siteInfoService.fetchSiteInfo();
-            }
-            catch (error) {
-                console.error(chalk.red('Error fetching site information'));
-                throw error;
-            }
-        }
-        // Add default site to the list
-        const defaultSite = {
-            name: config.defaultSite,
-            hostName: '*',
-            language: config.defaultLanguage,
-        };
-        sites.unshift(defaultSite);
-        ensurePathExists(sitesFilePath);
-        fs.writeFileSync(sitesFilePath, JSON.stringify(sites, null, 2), { encoding: 'utf8' });
-    };
-};
+import path from 'path';
+import chalk from 'chalk';
+import fs from 'fs';
+import debug from '../debug';
+import { SiteInfoService } from '../site';
+import { ensurePathExists } from '../utils/ensurePath';
+import { createGraphQLClientFactory } from '../client';
+const DEFAULT_SITES_DIST_PATH = '.sitecore/sites.json';
+/**
+ * Generates site information and writes it to a specified destination path.
+ * @param {GenerateSitesConfig} config - The configuration for generating site info.
+ * @returns {Promise<Function>} - A promise that resolves to an asynchronous function that fetches site information and writes it to a file.
+ * @public
+ */
+export const generateSites = ({ scConfig: deprecatedScConfig, destinationPath, } = {}) => {
+    return async ({ scConfig } = {}) => {
+        const config = deprecatedScConfig !== null && deprecatedScConfig !== void 0 ? deprecatedScConfig : scConfig;
+        if (!config) {
+            throw new Error('Sitecore configuration is required to be provided');
+        }
+        let sites = [];
+        const sitesFilePath = path.resolve(destinationPath !== null && destinationPath !== void 0 ? destinationPath : DEFAULT_SITES_DIST_PATH);
+        debug.multisite(config.multisite.enabled
+            ? 'Multisite Enabled: Generating site information'
+            : 'Multisite Disabled');
+        if (config.multisite.enabled) {
+            try {
+                const siteInfoService = new SiteInfoService({
+                    clientFactory: createGraphQLClientFactory({
+                        api: config.api,
+                        retries: config.retries.count,
+                        retryStrategy: config.retries.retryStrategy,
+                    }),
+                });
+                sites = await siteInfoService.fetchSiteInfo();
+            }
+            catch (error) {
+                console.error(chalk.red('Error fetching site information'));
+                throw error;
+            }
+        }
+        // Add default site to the list
+        const defaultSite = {
+            name: config.defaultSite,
+            hostName: '*',
+            language: config.defaultLanguage,
+        };
+        sites.unshift(defaultSite);
+        ensurePathExists(sitesFilePath);
+        fs.writeFileSync(sitesFilePath, JSON.stringify(sites, null, 2), { encoding: 'utf8' });
+    };
+};

package/dist/esm/tools/index.js

@@ -1,27 +1,28 @@
-export { generateSites } from './generateSites';
-export { generateMetadata } from './generateMetadata';
-export { scaffoldComponent } from './scaffold';
-export { extractFiles } from './codegen/extract-files';
-export { writeImportMap } from './codegen/import-map';
-export { getComponentSpec, getComponentSpecUrl } from './codegen/component-generation';
-export * from './templating';
-export * from './auth/models';
-import * as authModule from './auth';
-/**
- * Preserve "live binding" semantics similar to ES module imports: production
- * code always sees the current implementation; tests can swap it safely and
- * restore via `sandbox.restore()` with no hidden global state.
- *
- * Public surface consumed by the rest of the codebase.
- */
-export const auth = {};
-/*
- * Define an accessor so reads are dynamic
- *   - Production: returns the real `authModule.clientCredentialsFlow`.
- *   - Tests: can be replaced with a stub via `sinon.replaceGetter` or `sandbox.replaceGetter`
- */
-Object.defineProperty(auth, 'clientCredentialsFlow', {
-    get: () => authModule.clientCredentialsFlow,
-    configurable: true,
-    enumerable: true,
-});
+export { generateSites } from './generateSites';
+export { generateMetadata } from './generateMetadata';
+export { scaffoldComponent } from './scaffold';
+export { extractFiles } from './codegen/extract-files';
+export { writeImportMap, defaultMapTemplate as defaultImportMapTemplate, } from './codegen/import-map';
+export { getComponentSpec, getComponentSpecUrl } from './codegen/component-generation';
+export * from './templating';
+export * from './auth/models';
+import * as authModule from './auth';
+/**
+ * Preserve "live binding" semantics similar to ES module imports: production
+ * code always sees the current implementation; tests can swap it safely and
+ * restore via `sandbox.restore()` with no hidden global state.
+ *
+ * Public surface consumed by the rest of the codebase.
+ * @public
+ */
+export const auth = {};
+/*
+ * Define an accessor so reads are dynamic
+ *   - Production: returns the real `authModule.clientCredentialsFlow`.
+ *   - Tests: can be replaced with a stub via `sinon.replaceGetter` or `sandbox.replaceGetter`
+ */
+Object.defineProperty(auth, 'clientCredentialsFlow', {
+    get: () => authModule.clientCredentialsFlow,
+    configurable: true,
+    enumerable: true,
+});

package/dist/esm/tools/scaffold.js

@@ -1,53 +1,54 @@
-import fs from 'fs';
-import chalk from 'chalk';
-import path from 'path';
-/**
- * Force to use `crlf` line endings, we are using `crlf` across the project.
- * Replace: `lf` (\n), `cr` (\r)
- * @param {string} content
- */
-export function editLineEndings(content) {
-    return content.replace(/\r|\n/gm, '\r\n');
-}
-/**
- * Creates a file relative to the specified path if the file doesn't exist.
- * Creates directories as needed.
- * Does not overwrite existing files.
- * @param {string} filePath - the file path
- * @param {string} fileContent - the file content
- * @returns {string} the file path if the file was created, otherwise null
- */
-export function scaffoldFile(filePath, fileContent) {
-    const outputDir = path.dirname(filePath);
-    if (fs.existsSync(filePath)) {
-        console.log(chalk.red(`Skipping creating ${filePath}; already exists.`));
-        return null;
-    }
-    fs.mkdirSync(outputDir, { recursive: true });
-    fs.writeFileSync(filePath, editLineEndings(fileContent), 'utf8');
-    console.log(chalk.green(`File ${filePath} has been scaffolded.`));
-    return filePath;
-}
-/**
- * Scaffolds a new component based on the provided template.
- * @param {string} outputFolderPath - The file path where the component will be created.
- * @param {string} componentName - The name of the component to be created.
- * @param {string} templateName - The name of the template to use for scaffolding. If not provided, defaults to 'byoc' if `byoc` is true, otherwise 'default'.
- * @param {ScaffoldTemplate[]} templates - An array of template objects, each containing a name, a template function, and a getNextSteps function.
- * @throws Will throw an error if the specified template is not found.
- */
-export function scaffoldComponent(outputFolderPath, componentName, templateName, templates) {
-    const template = templates.find((t) => t.name === templateName);
-    if (!template) {
-        throw new Error(`Template ${templateName} not found.`);
-    }
-    const outputFilePath = path.join(outputFolderPath, `${componentName}.${template.fileExtension}`);
-    const componentOutputPath = scaffoldFile(outputFilePath, template.generateTemplate(componentName));
-    if (componentOutputPath) {
-        const nextSteps = [];
+import fs from 'fs';
+import chalk from 'chalk';
+import path from 'path';
+/**
+ * Force to use `crlf` line endings, we are using `crlf` across the project.
+ * Replace: `lf` (\n), `cr` (\r)
+ * @param {string} content
+ */
+export function editLineEndings(content) {
+    return content.replace(/\r|\n/gm, '\r\n');
+}
+/**
+ * Creates a file relative to the specified path if the file doesn't exist.
+ * Creates directories as needed.
+ * Does not overwrite existing files.
+ * @param {string} filePath - the file path
+ * @param {string} fileContent - the file content
+ * @returns {string} the file path if the file was created, otherwise null
+ */
+export function scaffoldFile(filePath, fileContent) {
+    const outputDir = path.dirname(filePath);
+    if (fs.existsSync(filePath)) {
+        console.log(chalk.red(`Skipping creating ${filePath}; already exists.`));
+        return null;
+    }
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(filePath, editLineEndings(fileContent), 'utf8');
+    console.log(chalk.green(`File ${filePath} has been scaffolded.`));
+    return filePath;
+}
+/**
+ * Scaffolds a new component based on the provided template.
+ * @param {string} outputFolderPath - The file path where the component will be created.
+ * @param {string} componentName - The name of the component to be created.
+ * @param {string} templateName - The name of the template to use for scaffolding. If not provided, defaults to 'byoc' if `byoc` is true, otherwise 'default'.
+ * @param {ScaffoldTemplate[]} templates - An array of template objects, each containing a name, a template function, and a getNextSteps function.
+ * @throws Will throw an error if the specified template is not found.
+ * @internal
+ */
+export function scaffoldComponent(outputFolderPath, componentName, templateName, templates) {
+    const template = templates.find((t) => t.name === templateName);
+    if (!template) {
+        throw new Error(`Template ${templateName} not found.`);
+    }
+    const outputFilePath = path.join(outputFolderPath, `${componentName}.${template.fileExtension}`);
+    const componentOutputPath = scaffoldFile(outputFilePath, template.generateTemplate(componentName));
+    if (componentOutputPath) {
+        const nextSteps = [];
         nextSteps.push(chalk.green(`
     Scaffolding of ${componentName} complete.
-    Next steps:`), ...(template.getNextSteps ? template.getNextSteps(componentOutputPath) : []));
-        console.log(nextSteps.join('\n'));
-    }
-}
+    Next steps:`), ...(template.getNextSteps ? template.getNextSteps(componentOutputPath) : []));
+        console.log(nextSteps.join('\n'));
+    }
+}

package/dist/esm/tools/templating/components.js

@@ -1,223 +1,59 @@
-import * as glob from 'glob';
-import fs from 'fs';
-import * as ts from 'typescript';
-export let getComponentList = _getComponentList;
-export const componentUnitMocks = {
-    set getComponentList(mockImplementation) {
-        getComponentList = mockImplementation;
-    },
-    get getComponentList() {
-        return _getComponentList;
-    },
-};
-const componentNamePattern = /^[\/]*(.+[\/\\])*(.+)\.[jt]sx?$/;
-const componentPathPattern = /^([\/]*.+[\/\\].+)\..+$/;
-/**
- * Get list of components from @var path
- * Returns a list of components in the following format:
- * {
- *  path: 'path/to/component',
- *  componentName: 'ComponentName',
- *  moduleName: 'ComponentName'
- * }
- * @param {string[]} paths paths to search
- * @param {string[]} [exclude] paths and glob patterns to exclude from final result
- * @param {boolean} [includeVariants] whether to include variant components
- */
-function _getComponentList(paths, exclude, includeVariants) {
-    const components = paths.reduce((result, path) => {
-        const globPath = glob.hasMagic(path, { magicalBraces: true }) || path.match(componentNamePattern)
-            ? path
-            : path.replace(/\/$/, '').concat('/**/*.{js,jsx,ts,tsx}');
-        return result.concat(...glob
-            .sync(globPath, { ignore: exclude, nodir: true })
-            .filter((path) => path.match(componentNamePattern))
-            .map((filePath) => {
-            const name = filePath.match(componentNamePattern)[2];
-            return {
-                filePath,
-                importPath: filePath.match(componentPathPattern)[1].replace(/\\/g, '/'), // use forward slashes for consistency
-                componentName: name,
-                moduleName: name.replace(/[^\w]+/g, ''),
-            };
-        }));
-    }, []);
-    return includeVariants
-        ? components
-        : components.filter((component) => !component.componentName.includes('.'));
-}
-/**
- * Detects the Next.js router type (App Router or Pages Router) based on directory structure.
- * @param {string} projectRoot - The project root directory. Defaults to current working directory.
- * @returns {RouterType} 'app' if App Router is detected, 'pages' otherwise
- */
-export function detectRouterType(projectRoot = process.cwd()) {
-    const appDirExists = fs.existsSync(`${projectRoot}/src/app`) || fs.existsSync(`${projectRoot}/app`);
-    const pagesDirExists = fs.existsSync(`${projectRoot}/src/pages`) || fs.existsSync(`${projectRoot}/pages`);
-    if (appDirExists) {
-        return 'app';
-    }
-    if (pagesDirExists) {
-        return 'pages';
-    }
-    return 'pages';
-}
-/**
- * Detects the component type based on directives, imports, and router context.
- * - Checks for 'use client' directive
- * - Checks for explicit componentType export
- * - Checks for server-only imports (next/headers, etc.)
- * - Defaults to 'server' for App Router, 'universal' for Pages Router
- * @param {string} filePath - Path to the component file
- * @param {RouterType} [routerType] - Optional router type override. Auto-detected if not provided.
- * @returns {ComponentType} 'server', 'client', or 'universal'
- */
-export function detectComponentType(filePath, routerType) {
-    try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        // Parse using TypeScript AST (following patterns from import-map.ts and utils.ts)
-        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-        let hasUseClientDirective = false;
-        let explicitComponentType = null;
-        let hasServerOnlyImports = false;
-        // Auto-detect router type if not provided
-        const detectedRouterType = routerType || detectRouterType();
-        // Track position to ensure directives come before imports/other statements
-        let foundFirstNonDirectiveStatement = false;
-        // Helper function to check if a node is a valid directive
-        const isValidDirective = (node) => {
-            return (ts.isExpressionStatement(node) &&
-                ts.isStringLiteral(node.expression) &&
-                !foundFirstNonDirectiveStatement);
-        };
-        // More comprehensive AST traversal (following patterns from import-map.ts and utils.ts)
-        const traverseNode = (node) => {
-            var _a;
-            // Check for 'use client'/'use server' directives (must be at top, before imports)
-            if (isValidDirective(node) &&
-                ts.isStringLiteral(node.expression)) {
-                const directiveText = node.expression
-                    .text;
-                if (directiveText === 'use client') {
-                    hasUseClientDirective = true;
-                    return; // Don't mark as non-directive statement
-                }
-                if (directiveText === 'use server') {
-                    explicitComponentType = 'server';
-                    return; // Don't mark as non-directive statement
-                }
-            }
-            // Mark that we've seen a non-directive statement (imports, declarations, etc.)
-            if (ts.isImportDeclaration(node) ||
-                ts.isVariableStatement(node) ||
-                ts.isFunctionDeclaration(node) ||
-                ts.isExportDeclaration(node) ||
-                ts.isExportAssignment(node)) {
-                foundFirstNonDirectiveStatement = true;
-            }
-            // Check for import declarations with server-only modules
-            if (ts.isImportDeclaration(node)) {
-                const moduleSpecifier = node.moduleSpecifier;
-                if (ts.isStringLiteral(moduleSpecifier)) {
-                    const importPath = moduleSpecifier.text;
-                    // Expand server-only module detection
-                    if (importPath === 'next/headers' ||
-                        importPath === 'server-only' ||
-                        importPath === 'next/cache' ||
-                        importPath === 'next/cookies' ||
-                        importPath.startsWith('node:') ||
-                        importPath === 'fs' ||
-                        importPath === 'path') {
-                        hasServerOnlyImports = true;
-                    }
-                }
-            }
-            // Check for explicit componentType export (improved detection)
-            if (ts.isVariableStatement(node)) {
-                const hasExportModifier = (_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
-                if (hasExportModifier) {
-                    node.declarationList.declarations.forEach((declaration) => {
-                        if (ts.isIdentifier(declaration.name) &&
-                            declaration.name.text === 'componentType' &&
-                            declaration.initializer) {
-                            // Handle string literal
-                            if (ts.isStringLiteral(declaration.initializer)) {
-                                const typeValue = declaration.initializer.text;
-                                if (typeValue === 'server' || typeValue === 'client' || typeValue === 'universal') {
-                                    explicitComponentType = typeValue;
-                                }
-                            }
-                            // Handle template literal (e.g., `client`)
-                            else if (ts.isNoSubstitutionTemplateLiteral(declaration.initializer)) {
-                                const typeValue = declaration.initializer.text;
-                                if (typeValue === 'server' || typeValue === 'client' || typeValue === 'universal') {
-                                    explicitComponentType = typeValue;
-                                }
-                            }
-                        }
-                    });
-                }
-            }
-            // Check for named export of componentType (export const componentType = ...)
-            if (ts.isExportDeclaration(node) &&
-                node.exportClause &&
-                ts.isNamedExports(node.exportClause)) {
-                node.exportClause.elements.forEach((exportSpecifier) => {
-                    if (exportSpecifier.name.text === 'componentType') {
-                        // This would need additional logic to resolve the actual value, but for now
-                        // we'll rely on the variable declaration detection above
-                    }
-                });
-            }
-            // Recursively traverse child nodes (following import-map.ts pattern)
-            ts.forEachChild(node, traverseNode);
-        };
-        // Start traversal from the source file (following utils.ts pattern)
-        ts.forEachChild(sourceFile, traverseNode);
-        // Priority: explicit componentType export > use client/server directives > server-only imports > universal default
-        if (explicitComponentType) {
-            return explicitComponentType;
-        }
-        if (hasUseClientDirective) {
-            return 'client';
-        }
-        if (hasServerOnlyImports) {
-            return 'server';
-        }
-        // Router-aware defaults:
-        // - App Router: defaults to server (RSC by default)
-        // - Pages Router: defaults to universal (isomorphic by default)
-        if (detectedRouterType === 'app') {
-            return 'server';
-        }
-        else {
-            return 'universal';
-        }
-    }
-    catch (error) {
-        console.warn(`Failed to parse component file ${filePath}, defaulting to universal:`, error);
-        return 'universal';
-    }
-}
-/**
- * Get list of components with detected types (server, client, or universal).
- * @param {string[]} paths - Paths to search for components
- * @param {string[]} [exclude] - Paths and glob patterns to exclude from final result
- * @param {boolean} includeVariants - Whether to include variant components
- * @param {RouterType} [routerType] - Optional router type override for type detection. Auto-detected if not provided.
- * @returns {ComponentFileWithType[]} Array of components with their detected types
- */
-export function getComponentListWithTypes(paths, exclude, includeVariants, routerType) {
-    const components = getComponentList(paths, exclude, includeVariants);
-    const detectedRouterType = routerType || detectRouterType();
-    return components.map((component) => (Object.assign(Object.assign({}, component), { componentType: detectComponentType(component.filePath, detectedRouterType) })));
-}
-/**
- * Filters components by their detected type.
- * @param {ComponentFileWithType[]} components - Array of components with types
- * @param {ComponentType[]} allowedTypes - Array of allowed component types to filter by
- * @returns {ComponentFileWithType[]} Filtered array containing only components matching allowed types
- */
-export function filterComponentsByType(components, allowedTypes) {
-    return components.filter((component) => allowedTypes.includes(component.componentType));
-}
+import * as glob from 'glob';
+/**
+ * @public
+ */
+export let getComponentList = _getComponentList;
+export const componentUnitMocks = {
+    set getComponentList(mockImplementation) {
+        getComponentList = mockImplementation;
+    },
+    get getComponentList() {
+        return _getComponentList;
+    },
+};
+const componentNamePattern = /^[\/]*(.+[\/\\])*(.+)\.[jt]sx?$/;
+const componentPathPattern = /^([\/]*.+[\/\\].+)\..+$/;
+/**
+ * Get list of components from @var path
+ * Returns a list of components in the following format:
+ * {
+ *  path: 'path/to/component',
+ *  componentName: 'ComponentName',
+ *  moduleName: 'ComponentName'
+ * }
+ * @param {string[]} paths paths to search
+ * @param {string[]} [exclude] paths and glob patterns to exclude from final result
+ * @param {boolean} [includeVariants] whether to include variant components
+ */
+function _getComponentList(paths, exclude, includeVariants) {
+    const components = paths.reduce((result, path) => {
+        const globPath = glob.hasMagic(path, { magicalBraces: true }) || path.match(componentNamePattern)
+            ? path
+            : path.replace(/\/$/, '').concat('/**/*.{js,jsx,ts,tsx}');
+        return result.concat(...glob
+            .sync(globPath, { ignore: exclude, nodir: true })
+            .filter((path) => path.match(componentNamePattern))
+            .map((filePath) => {
+            const name = filePath.match(componentNamePattern)[2];
+            return {
+                filePath,
+                importPath: filePath.match(componentPathPattern)[1].replace(/\\/g, '/'), // use forward slashes for consistency
+                componentName: name,
+                moduleName: name.replace(/[^\w]+/g, ''),
+            };
+        }));
+    }, []);
+    return includeVariants
+        ? components
+        : components.filter((component) => !component.componentName.includes('.'));
+}
+/**
+ * Filters components by their detected type.
+ * @param {ComponentFileWithType[]} components - Array of components with types
+ * @param {ComponentType[]} allowedTypes - Array of allowed component types to filter by
+ * @returns {ComponentFileWithType[]} Filtered array containing only components matching allowed types
+ * @internal
+ */
+export function filterComponentsByType(components, allowedTypes) {
+    return components.filter((component) => allowedTypes.includes(component.componentType));
+}

package/dist/esm/tools/templating/index.js

@@ -1,3 +1,3 @@
-export { getComponentList, detectRouterType, detectComponentType, getComponentListWithTypes, filterComponentsByType, } from './components';
-export { generatePlugins, ModuleType } from './plugins';
-export { matchPath } from './utils';
+export { getComponentList, filterComponentsByType, } from './components';
+export { generatePlugins, ModuleType } from './plugins';
+export { matchPath } from './utils';