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

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

@@ -1,266 +1,96 @@
-"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.componentUnitMocks = exports.getComponentList = void 0;
-exports.detectRouterType = detectRouterType;
-exports.detectComponentType = detectComponentType;
-exports.getComponentListWithTypes = getComponentListWithTypes;
-exports.filterComponentsByType = filterComponentsByType;
-const glob = __importStar(require("glob"));
-const fs_1 = __importDefault(require("fs"));
-const ts = __importStar(require("typescript"));
-exports.getComponentList = _getComponentList;
-exports.componentUnitMocks = {
-    set getComponentList(mockImplementation) {
-        exports.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
- */
-function detectRouterType(projectRoot = process.cwd()) {
-    const appDirExists = fs_1.default.existsSync(`${projectRoot}/src/app`) || fs_1.default.existsSync(`${projectRoot}/app`);
-    const pagesDirExists = fs_1.default.existsSync(`${projectRoot}/src/pages`) || fs_1.default.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'
- */
-function detectComponentType(filePath, routerType) {
-    try {
-        const content = fs_1.default.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
- */
-function getComponentListWithTypes(paths, exclude, includeVariants, routerType) {
-    const components = (0, exports.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
- */
-function filterComponentsByType(components, allowedTypes) {
-    return components.filter((component) => allowedTypes.includes(component.componentType));
-}
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentUnitMocks = exports.getComponentList = void 0;
+exports.filterComponentsByType = filterComponentsByType;
+const glob = __importStar(require("glob"));
+/**
+ * @public
+ */
+exports.getComponentList = _getComponentList;
+exports.componentUnitMocks = {
+    set getComponentList(mockImplementation) {
+        exports.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
+ */
+function filterComponentsByType(components, allowedTypes) {
+    return components.filter((component) => allowedTypes.includes(component.componentType));
+}

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

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchPath = exports.ModuleType = exports.generatePlugins = exports.filterComponentsByType = exports.getComponentListWithTypes = exports.detectComponentType = exports.detectRouterType = exports.getComponentList = void 0;
-var components_1 = require("./components");
-Object.defineProperty(exports, "getComponentList", { enumerable: true, get: function () { return components_1.getComponentList; } });
-Object.defineProperty(exports, "detectRouterType", { enumerable: true, get: function () { return components_1.detectRouterType; } });
-Object.defineProperty(exports, "detectComponentType", { enumerable: true, get: function () { return components_1.detectComponentType; } });
-Object.defineProperty(exports, "getComponentListWithTypes", { enumerable: true, get: function () { return components_1.getComponentListWithTypes; } });
-Object.defineProperty(exports, "filterComponentsByType", { enumerable: true, get: function () { return components_1.filterComponentsByType; } });
-var plugins_1 = require("./plugins");
-Object.defineProperty(exports, "generatePlugins", { enumerable: true, get: function () { return plugins_1.generatePlugins; } });
-Object.defineProperty(exports, "ModuleType", { enumerable: true, get: function () { return plugins_1.ModuleType; } });
-var utils_1 = require("./utils");
-Object.defineProperty(exports, "matchPath", { enumerable: true, get: function () { return utils_1.matchPath; } });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchPath = exports.ModuleType = exports.generatePlugins = exports.filterComponentsByType = exports.getComponentList = void 0;
+var components_1 = require("./components");
+Object.defineProperty(exports, "getComponentList", { enumerable: true, get: function () { return components_1.getComponentList; } });
+Object.defineProperty(exports, "filterComponentsByType", { enumerable: true, get: function () { return components_1.filterComponentsByType; } });
+var plugins_1 = require("./plugins");
+Object.defineProperty(exports, "generatePlugins", { enumerable: true, get: function () { return plugins_1.generatePlugins; } });
+Object.defineProperty(exports, "ModuleType", { enumerable: true, get: function () { return plugins_1.ModuleType; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "matchPath", { enumerable: true, get: function () { return utils_1.matchPath; } });

package/dist/cjs/tools/templating/plugins.js

@@ -1,78 +1,80 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleType = void 0;
-exports.getPluginList = getPluginList;
-exports.generatePlugins = generatePlugins;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const utils_1 = require("./utils");
-/**
- * Identifies the format of the module to be compiled
- */
-var ModuleType;
-(function (ModuleType) {
-    ModuleType[ModuleType["CJS"] = 0] = "CJS";
-    ModuleType[ModuleType["ESM"] = 1] = "ESM";
-})(ModuleType || (exports.ModuleType = ModuleType = {}));
-/**
- * Get list of plugins from @var path
- * Returns a list of plugins in the following format:
- * {
- *   path: 'path/to/plugin/foo',
- *   name: 'fooPlugin'
- * }
- * @example getPluginList('src/foo/plugins', 'Foo')
- * @param {object} definition plugin definition
- * @param {string} definition.path path to get plugin from
- * @param {string} definition.pluginName plugin name
- * @param {boolean} [definition.silent] whether to suppress console output
- */
-function getPluginList({ path, pluginName, silent = false, }) {
-    const plugins = (0, utils_1.getItems)({
-        path,
-        resolveItem: (path, name) => ({
-            path: `${path}/${name}`,
-            name: `${name.replace(/-./g, (x) => x[1].toUpperCase())}Plugin`,
-        }),
-        cb: (name) => !silent && console.debug(`Registering ${pluginName} plugin ${name}`),
-    });
-    return plugins;
-}
-/**
- * Generates the plugins file and saves it to the filesystem.
- * By convention, we expect to find plugins under {pluginName}/plugins/** (subfolders are searched recursively).
- * generated file will be saved to @var {distPath} and will contain a list of plugins in the following format:
- * CJS: exports.fooPlugin = require('{pluginPath}');
- * ESM: export { fooPlugin } from '{pluginPath}';
- * @example generatePlugins({ distPath: 'src/temp/foo-plugins.js', rootPath: 'src/foo/plugins', moduleType: ModuleType.CJS })
- * @param {PluginDefinition} definition plugin definition
- */
-function generatePlugins(definition) {
-    const { rootPath, distPath, moduleType, relative = false, silent } = definition;
-    const segments = rootPath.split('/');
-    const pluginName = segments[segments.length - 2];
-    const plugins = getPluginList({ path: rootPath, pluginName, silent });
-    let fileContent = '';
-    fileContent = plugins
-        .map((plugin) => {
-        const sourcePath = relative
-            ? path_1.default.relative(path_1.default.dirname(distPath), plugin.path).replace(/\\/g, '/')
-            : plugin.path;
-        return moduleType === ModuleType.CJS
-            ? `exports.${plugin.name} = require('${sourcePath}');`
-            : `export { ${plugin.name} } from '${sourcePath}';`;
-    })
-        .join('\r\n')
-        .concat('\r\n');
-    if (!plugins.length) {
-        fileContent = moduleType === ModuleType.CJS ? 'module.exports = {};\r\n' : 'export {};\r\n';
-    }
-    const filePath = path_1.default.resolve(distPath);
-    !silent && console.log(`Writing ${pluginName} plugins to ${filePath}`);
-    fs_1.default.writeFileSync(filePath, fileContent, {
-        encoding: 'utf8',
-    });
-}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleType = void 0;
+exports.getPluginList = getPluginList;
+exports.generatePlugins = generatePlugins;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+/**
+ * Identifies the format of the module to be compiled
+ * @public
+ */
+var ModuleType;
+(function (ModuleType) {
+    ModuleType[ModuleType["CJS"] = 0] = "CJS";
+    ModuleType[ModuleType["ESM"] = 1] = "ESM";
+})(ModuleType || (exports.ModuleType = ModuleType = {}));
+/**
+ * Get list of plugins from @var path
+ * Returns a list of plugins in the following format:
+ * {
+ *   path: 'path/to/plugin/foo',
+ *   name: 'fooPlugin'
+ * }
+ * @example getPluginList('src/foo/plugins', 'Foo')
+ * @param {object} definition plugin definition
+ * @param {string} definition.path path to get plugin from
+ * @param {string} definition.pluginName plugin name
+ * @param {boolean} [definition.silent] whether to suppress console output
+ */
+function getPluginList({ path, pluginName, silent = false, }) {
+    const plugins = (0, utils_1.getItems)({
+        path,
+        resolveItem: (path, name) => ({
+            path: `${path}/${name}`,
+            name: `${name.replace(/-./g, (x) => x[1].toUpperCase())}Plugin`,
+        }),
+        cb: (name) => !silent && console.debug(`Registering ${pluginName} plugin ${name}`),
+    });
+    return plugins;
+}
+/**
+ * Generates the plugins file and saves it to the filesystem.
+ * By convention, we expect to find plugins under {pluginName}/plugins/** (subfolders are searched recursively).
+ * generated file will be saved to @var {distPath} and will contain a list of plugins in the following format:
+ * CJS: exports.fooPlugin = require('{pluginPath}');
+ * ESM: export { fooPlugin } from '{pluginPath}';
+ * @example generatePlugins({ distPath: 'src/temp/foo-plugins.js', rootPath: 'src/foo/plugins', moduleType: ModuleType.CJS })
+ * @param {PluginDefinition} definition plugin definition
+ * @public
+ */
+function generatePlugins(definition) {
+    const { rootPath, distPath, moduleType, relative = false, silent } = definition;
+    const segments = rootPath.split('/');
+    const pluginName = segments[segments.length - 2];
+    const plugins = getPluginList({ path: rootPath, pluginName, silent });
+    let fileContent = '';
+    fileContent = plugins
+        .map((plugin) => {
+        const sourcePath = relative
+            ? path_1.default.relative(path_1.default.dirname(distPath), plugin.path).replace(/\\/g, '/')
+            : plugin.path;
+        return moduleType === ModuleType.CJS
+            ? `exports.${plugin.name} = require('${sourcePath}');`
+            : `export { ${plugin.name} } from '${sourcePath}';`;
+    })
+        .join('\r\n')
+        .concat('\r\n');
+    if (!plugins.length) {
+        fileContent = moduleType === ModuleType.CJS ? 'module.exports = {};\r\n' : 'export {};\r\n';
+    }
+    const filePath = path_1.default.resolve(distPath);
+    !silent && console.log(`Writing ${pluginName} plugins to ${filePath}`);
+    fs_1.default.writeFileSync(filePath, fileContent, {
+        encoding: 'utf8',
+    });
+}