js-template-engine 1.0.1 → 2.0.0

package/README.md

@@ -1,184 +1,131 @@
-# JS Template Engine
+# js-template-engine
 
-A dynamic templating engine that translates JavaScript or JSON data into structured templates across multiple languages. At its core this tool generates HTML templates, but the concept is modular and can be extended to render templates for any framework or templating language imaginable.
+The command-line interface for the JS Template Engine. Renders UI components
+defined as plain, typed data to vanilla HTML/CSS/JS or to React, Vue, and
+Svelte components — with styling methodologies (BEM, Tailwind) applied as
+extensions.
 
-## Features
-
-- Ideal for UI libraries: Maintain one single source of truth and avoid double maintaining different language variations of your components.
-- Customizable: Does it not yet support your templating language of choice? The abstract logic allows you to create and use your own extensions.
-- Native Extensions: There's a growing ecosystem of extensions, i.e. React to generate JSX components and BEM to enforce consistent class naming.
-- CLI Interface: A convenient CLI tool that can both process single JSON files and traverse through nested folder structures from the command line.
-- Flexible Configuration: Customize the output directory, apply framework-specific extensions, and more through CLI options or configuration files.
+```bash
+npx js-template-engine render button.json --framework react
+```
 
 ## Installation
 
-```sh
-npm install js-template-engine
+```bash
+npm install --save-dev js-template-engine
+# or globally:
+npm install --global js-template-engine
 ```
 
-Or if you prefer using Yarn:
+## Commands
 
-```sh
-yarn add js-template-engine
-```
+### `render <source>`
 
-## Usage
+Renders a template file — or every template in a directory — and writes the
+generated files.
 
-### CLI
+```bash
+# Vanilla HTML/CSS/JS (the default):
+js-template-engine render button.json
 
-The JS Template Engine CLI provides a straightforward way to render templates from JSON files:
+# A React component with BEM classes:
+js-template-engine render button.json --framework react --styling bem
 
-```sh
-js-template-engine render <sourcePath> [options]
+# Every template in src/components, as Svelte components, into dist/svelte:
+js-template-engine render src/components --framework svelte --output-directory dist/svelte
 ```
 
-**Arguments:**
-
-- `<sourcePath>`: The path to the JSON file or directory containing JSON templates you wish to render.
-
-**Options:**
-
-- `--outputDir`, `-o`: Specify the output directory for rendered templates.
-- `--extensions`, `-e`: Choose extensions to use for template processing (e.g., react, bem).
-- `--name`, `-n`: Set a base name for output files.
-- `--componentName`, `-c`: Define a component name for framework-specific templates (useful for React).
-- `--verbose`, `-v`: Enable verbose logging for more detailed output.
-
-### Examples
-
-Feel free to check out the [examples folder](examples), to get a better idea of some of the core concepts and extensions. The provided examples can be run using:
-
-```sh
-npm run example:react
-npm run example:bem
-npm run example:slots
-
+| Option | Default | |
+|---|---|---|
+| `--framework <name>` | — | `react`, `vue`, or `svelte`; omitted renders HTML |
+| `--styling <names>` | — | comma-separated styling extensions (`bem`, `tailwind`), applied in order |
+| `-o, --output-directory <path>` | `./output` | directory generated files are written to |
+| `-n, --component-name <name>` | filename | component name for templates that declare none |
+| `--styling-strategy <strategy>` | `in-file` | `inline`, `in-file`, or `separate-file` |
+| `--styling-language <language>` | `css` | `css`, or `scss` for nested output; react and HTML require `--styling-strategy separate-file` under `scss` |
+| `--scripting-strategy <strategy>` | `in-file` | `inline`, `in-file`, or `separate-file` |
+| `--scripting-language <language>` | `javascript` | `javascript`, or `typescript` to type the generated prop consts; affects HTML mode only and requires `--scripting-strategy separate-file` (writing `<Name>.ts`) |
+| `--bem-element-separator <separator>` | `__` | separator between BEM block and element |
+| `--bem-modifier-separator <separator>` | `--` | separator before a BEM modifier |
+| `--tailwind-output <output>` | `classes` | `classes` passes utilities through for Tailwind's build; `styles` converts them into the generated CSS |
+| `--tailwind-convert-styles` | off | convert each element's authored `style` into Tailwind utility classes |
+
+Warnings are printed to stderr; written files are listed on stdout. When a
+template in a directory fails, the remaining templates still render and the
+command exits non-zero.
+
+### `validate <source>`
+
+Validates a template file — or every template in a directory — against the
+template format, without writing anything.
+
+```bash
+js-template-engine validate src/components
 ```
 
-Or if you prefer using Yarn:
-
-```sh
-yarn example:react
-yarn example:bem
-yarn example:slots
-```
-
-### API
-
-You can also use JS Template Engine programmatically in your Node.js projects. This is how you could define and process your template using the BEM extension:
-
-```javascript
-const { TemplateEngine, BemExtension } = require("js-template-engine");
-
-const templateEngine = new TemplateEngine();
-const bemExtension = new BemExtension();
-
-const breadcrumbsTemplate = [
-  {
-    tag: "nav",
-    extensions: {
-      bem: {
-        block: "breadcrumbs",
-      },
+Each valid template is confirmed on stdout; each invalid one is reported on
+stderr with the path of the offending node. The command exits non-zero when
+any template is invalid.
+
+## Template files
+
+A template is plain serializable data, so the CLI accepts it in several
+forms:
+
+- **`.json`** — the transport form.
+- **`.ts`, `.js`, `.mjs`, `.cjs`** — a module whose default export is the
+  template. TypeScript files are loaded directly; no build step is needed.
+
+```ts
+// button.ts
+import { defineTemplate } from '@js-template-engine/types';
+
+export default defineTemplate({
+  type: 'component',
+  name: 'Button',
+  children: [
+    {
+      type: 'element',
+      tag: 'button',
+      attributes: { class: ['button'] },
+      events: [{ name: 'click', handler: 'handleClick' }],
+      children: [{ type: 'text', content: 'Click me' }],
     },
-    children: [
-      {
-        tag: "ul",
-
-        extensions: {
-          bem: {
-            element: "list",
-          },
-        },
-        children: [
-          {
-            tag: "li",
-
-            extensions: {
-              bem: {
-                element: "item",
-              },
-            },
-            children: [
-              {
-                tag: "a",
-                extensions: {
-                  bem: {
-                    element: "text",
-                  },
-                },
-                attributes: {
-                  href: "/",
-                },
-                children: [
-                  {
-                    type: "text",
-                    content: "Home",
-                  },
-                ],
-              },
-            ],
-          },
-          {
-            tag: "li",
-            extensions: {
-              bem: {
-                element: "item",
-                modifier: "current",
-              },
-            },
-            children: [
-              {
-                tag: "span",
-                extensions: {
-                  bem: {
-                    element: "text",
-                  },
-                },
-                children: [
-                  {
-                    type: "text",
-                    content: "About",
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-      },
-    ],
-  },
-];
-
-templateEngine.render(breadcrumbsTemplate, {
-  name: "breadcrumbs",
-  extensions: [bemExtension],
+  ],
 });
 ```
 
-This is what it would result in:
-
-```html
-<nav class="breadcrumbs">
-  <ul class="breadcrumbs__list">
-    <li class="breadcrumbs__item">
-      <a href="/" class="breadcrumbs__text">Home</a>
-    </li>
-    <li class="breadcrumbs__item breadcrumbs__item--current">
-      <span class="breadcrumbs__text">About</span>
-    </li>
-  </ul>
-</nav>
+```bash
+js-template-engine render button.ts --framework vue
+# wrote output/Button.vue
 ```
 
-## Contributing
+When a directory is given, every template file directly inside it is
+rendered; subdirectories are not searched.
+
+## Component names
+
+The name decides the generated file names (`Button.tsx`, `Button.vue`, …)
+and the component identifier inside them. It is resolved in order:
 
-Contributions are welcome! Feel free to open pull requests or issues to suggest features, report bugs, or contribute to the code.
+1. the template's own `name`, when it has a `component` root;
+2. the `--component-name` flag;
+3. the source filename, PascalCased (`icon-badge.json` → `IconBadge`).
 
-## Reporting Issues
+## Programmatic use
 
-Found a bug or have a suggestion? Please use the GitHub Issues page to report issues or request features.
+The CLI is a thin shell over `@js-template-engine/core`. For build scripts
+and tooling, use the engine directly — extensions are passed as objects, no
+name mapping involved:
 
-## License
+```ts
+import { process } from '@js-template-engine/core';
+import { react } from '@js-template-engine/extension-react';
+import { bem } from '@js-template-engine/extension-bem';
+
+const result = process(template, { extensions: [react(), bem()] });
+// result.files → [{ path: 'Button.tsx', content: '...' }]
+```
 
-This project is licensed under the MIT License - see the LICENSE file for details.
+Third-party extensions plug in through that API; the CLI's `--framework`
+and `--styling` flags cover the published extensions.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const program_1 = require("./program");
+void (0, program_1.createProgram)()
+    .parseAsync(process.argv)
+    .catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/commands/render.d.ts

@@ -0,0 +1,29 @@
+import type { OutputStrategy } from '@js-template-engine/types';
+import { type FrameworkName, type StylingName } from '../extensions';
+/** The `render` command's parsed options. */
+export interface RenderCommandOptions {
+    framework?: FrameworkName;
+    styling: StylingName[];
+    outputDirectory: string;
+    componentName?: string;
+    stylingStrategy: OutputStrategy;
+    stylingLanguage: 'css' | 'scss';
+    scriptingStrategy: OutputStrategy;
+    scriptingLanguage: 'javascript' | 'typescript';
+    bemElementSeparator?: string;
+    bemModifierSeparator?: string;
+    tailwindOutput?: 'classes' | 'styles';
+    tailwindConvertStyles?: boolean;
+}
+/**
+ * Renders one template file, or every template in a directory, and writes
+ * the generated files under the output directory.
+ *
+ * Warnings go to stderr; written files are listed on stdout. A template
+ * that fails to load or process is reported and does not stop the
+ * remaining templates; any failure makes the command exit non-zero.
+ *
+ * @param source - A template file or a directory of template files.
+ * @param options - The parsed command-line options.
+ */
+export declare function renderCommand(source: string, options: RenderCommandOptions): Promise<void>;

package/dist/commands/render.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCommand = renderCommand;
+const node_path_1 = require("node:path");
+const core_1 = require("@js-template-engine/core");
+const component_name_1 = require("../component-name");
+const extensions_1 = require("../extensions");
+const output_1 = require("../output");
+const reporting_1 = require("../reporting");
+const template_sources_1 = require("../template-sources");
+/**
+ * Renders one template file, or every template in a directory, and writes
+ * the generated files under the output directory.
+ *
+ * Warnings go to stderr; written files are listed on stdout. A template
+ * that fails to load or process is reported and does not stop the
+ * remaining templates; any failure makes the command exit non-zero.
+ *
+ * @param source - A template file or a directory of template files.
+ * @param options - The parsed command-line options.
+ */
+async function renderCommand(source, options) {
+    let sources;
+    try {
+        sources = (0, template_sources_1.resolveTemplateSources)(source);
+    }
+    catch (error) {
+        console.error(`error: ${(0, reporting_1.formatError)(error)}`);
+        process.exitCode = 1;
+        return;
+    }
+    let failed = false;
+    for (const filePath of sources) {
+        const label = (0, reporting_1.sourceLabel)(filePath);
+        try {
+            const template = await (0, template_sources_1.loadTemplate)(filePath);
+            const result = (0, core_1.process)(template, {
+                componentName: options.componentName ?? (0, component_name_1.componentNameFromFilePath)(filePath),
+                extensions: (0, extensions_1.buildExtensions)(options.framework, options.styling, {
+                    elementSeparator: options.bemElementSeparator,
+                    modifierSeparator: options.bemModifierSeparator,
+                }, {
+                    output: options.tailwindOutput,
+                    convertStyles: options.tailwindConvertStyles,
+                }),
+                styling: {
+                    outputStrategy: options.stylingStrategy,
+                    language: options.stylingLanguage,
+                },
+                scripting: {
+                    outputStrategy: options.scriptingStrategy,
+                    language: options.scriptingLanguage,
+                },
+            });
+            for (const warning of result.warnings) {
+                const location = warning.nodePath === undefined || warning.nodePath === ''
+                    ? ''
+                    : ` (at ${warning.nodePath})`;
+                console.error(`${label}: warning: ${warning.message}${location}`);
+            }
+            for (const writtenPath of (0, output_1.writeOutputFiles)(result.files, options.outputDirectory)) {
+                console.log(`wrote ${(0, node_path_1.relative)(process.cwd(), writtenPath)}`);
+            }
+        }
+        catch (error) {
+            failed = true;
+            console.error(`${label}: error: ${(0, reporting_1.formatError)(error)}`);
+        }
+    }
+    if (failed) {
+        process.exitCode = 1;
+    }
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Validates one template file, or every template in a directory.
+ *
+ * Each valid template is confirmed on stdout; each invalid one is reported
+ * on stderr with the offending node path. The command exits non-zero when
+ * any template fails to load or validate.
+ *
+ * @param source - A template file or a directory of template files.
+ */
+export declare function validateCommand(source: string): Promise<void>;

package/dist/commands/validate.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCommand = validateCommand;
+const core_1 = require("@js-template-engine/core");
+const reporting_1 = require("../reporting");
+const template_sources_1 = require("../template-sources");
+/**
+ * Validates one template file, or every template in a directory.
+ *
+ * Each valid template is confirmed on stdout; each invalid one is reported
+ * on stderr with the offending node path. The command exits non-zero when
+ * any template fails to load or validate.
+ *
+ * @param source - A template file or a directory of template files.
+ */
+async function validateCommand(source) {
+    let sources;
+    try {
+        sources = (0, template_sources_1.resolveTemplateSources)(source);
+    }
+    catch (error) {
+        console.error(`error: ${(0, reporting_1.formatError)(error)}`);
+        process.exitCode = 1;
+        return;
+    }
+    let failed = false;
+    for (const filePath of sources) {
+        const label = (0, reporting_1.sourceLabel)(filePath);
+        try {
+            const template = await (0, template_sources_1.loadTemplate)(filePath);
+            (0, core_1.validateTemplate)(template);
+            console.log(`${label}: valid`);
+        }
+        catch (error) {
+            failed = true;
+            console.error(`${label}: invalid — ${(0, reporting_1.formatError)(error)}`);
+        }
+    }
+    if (failed) {
+        process.exitCode = 1;
+    }
+}

package/dist/component-name.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Derives a component name from a template file path.
+ *
+ * The file's base name is split on every non-alphanumeric character and the
+ * segments are joined in PascalCase: `theme-toggle.json` → `ThemeToggle`,
+ * `user_card.ts` → `UserCard`. A name starting with a digit is prefixed
+ * with an underscore to stay a valid JavaScript identifier.
+ *
+ * Used when the template carries no component name of its own and no
+ * `--component-name` flag is given.
+ *
+ * @param filePath - The template file path.
+ * @returns The derived component name.
+ */
+export declare function componentNameFromFilePath(filePath: string): string;

package/dist/component-name.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentNameFromFilePath = componentNameFromFilePath;
+const node_path_1 = require("node:path");
+/**
+ * Derives a component name from a template file path.
+ *
+ * The file's base name is split on every non-alphanumeric character and the
+ * segments are joined in PascalCase: `theme-toggle.json` → `ThemeToggle`,
+ * `user_card.ts` → `UserCard`. A name starting with a digit is prefixed
+ * with an underscore to stay a valid JavaScript identifier.
+ *
+ * Used when the template carries no component name of its own and no
+ * `--component-name` flag is given.
+ *
+ * @param filePath - The template file path.
+ * @returns The derived component name.
+ */
+function componentNameFromFilePath(filePath) {
+    const stem = (0, node_path_1.basename)(filePath, (0, node_path_1.extname)(filePath));
+    const name = stem
+        .split(/[^a-zA-Z0-9]+/)
+        .filter((segment) => segment.length > 0)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+    if (name === '') {
+        return 'Component';
+    }
+    return /^[0-9]/.test(name) ? `_${name}` : name;
+}

package/dist/extensions.d.ts

@@ -0,0 +1,23 @@
+import { type BemOptions } from '@js-template-engine/extension-bem';
+import { type TailwindOptions } from '@js-template-engine/extension-tailwind';
+import type { Extension } from '@js-template-engine/types';
+/** The framework names the CLI can render with. */
+export declare const frameworkNames: readonly ["react", "vue", "svelte"];
+/** The styling extension names the CLI can apply. */
+export declare const stylingNames: readonly ["bem", "tailwind"];
+export type FrameworkName = (typeof frameworkNames)[number];
+export type StylingName = (typeof stylingNames)[number];
+/**
+ * Builds the extension list for one `process()` call.
+ *
+ * Styling extensions come first, in the order they were named on the
+ * command line — the order their classes are contributed in — followed by
+ * the framework extension, if any.
+ *
+ * @param framework - The framework to render with; `undefined` renders HTML.
+ * @param styling - Styling extension names, in application order.
+ * @param bemOptions - Options forwarded to the BEM extension factory.
+ * @param tailwindOptions - Options forwarded to the Tailwind extension factory.
+ * @returns Extension instances ready for `process()`.
+ */
+export declare function buildExtensions(framework: FrameworkName | undefined, styling: readonly StylingName[], bemOptions?: BemOptions, tailwindOptions?: TailwindOptions): Extension[];

package/dist/extensions.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stylingNames = exports.frameworkNames = void 0;
+exports.buildExtensions = buildExtensions;
+const extension_bem_1 = require("@js-template-engine/extension-bem");
+const extension_react_1 = require("@js-template-engine/extension-react");
+const extension_svelte_1 = require("@js-template-engine/extension-svelte");
+const extension_tailwind_1 = require("@js-template-engine/extension-tailwind");
+const extension_vue_1 = require("@js-template-engine/extension-vue");
+/** The framework names the CLI can render with. */
+exports.frameworkNames = ['react', 'vue', 'svelte'];
+/** The styling extension names the CLI can apply. */
+exports.stylingNames = ['bem', 'tailwind'];
+const frameworkFactories = {
+    react: extension_react_1.react,
+    vue: extension_vue_1.vue,
+    svelte: extension_svelte_1.svelte,
+};
+/**
+ * Builds the extension list for one `process()` call.
+ *
+ * Styling extensions come first, in the order they were named on the
+ * command line — the order their classes are contributed in — followed by
+ * the framework extension, if any.
+ *
+ * @param framework - The framework to render with; `undefined` renders HTML.
+ * @param styling - Styling extension names, in application order.
+ * @param bemOptions - Options forwarded to the BEM extension factory.
+ * @param tailwindOptions - Options forwarded to the Tailwind extension factory.
+ * @returns Extension instances ready for `process()`.
+ */
+function buildExtensions(framework, styling, bemOptions = {}, tailwindOptions = {}) {
+    const extensions = styling.map((name) => name === 'bem' ? (0, extension_bem_1.bem)(bemOptions) : (0, extension_tailwind_1.tailwind)(tailwindOptions));
+    if (framework !== undefined) {
+        extensions.push(frameworkFactories[framework]());
+    }
+    return extensions;
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Command-line interface for the JS Template Engine.
+ *
+ * The `js-template-engine` binary renders data-defined component templates
+ * to HTML, React, Vue, or Svelte (`render`) and validates template files
+ * (`validate`). This module exposes the program and its building blocks
+ * for programmatic use.
+ */
+export { componentNameFromFilePath } from './component-name';
+export { renderCommand, type RenderCommandOptions } from './commands/render';
+export { validateCommand } from './commands/validate';
+export { buildExtensions, frameworkNames, stylingNames, type FrameworkName, type StylingName, } from './extensions';
+export { writeOutputFiles } from './output';
+export { createProgram, parseStylingList } from './program';
+export { loadTemplate, resolveTemplateSources } from './template-sources';

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTemplateSources = exports.loadTemplate = exports.parseStylingList = exports.createProgram = exports.writeOutputFiles = exports.stylingNames = exports.frameworkNames = exports.buildExtensions = exports.validateCommand = exports.renderCommand = exports.componentNameFromFilePath = void 0;
+/**
+ * Command-line interface for the JS Template Engine.
+ *
+ * The `js-template-engine` binary renders data-defined component templates
+ * to HTML, React, Vue, or Svelte (`render`) and validates template files
+ * (`validate`). This module exposes the program and its building blocks
+ * for programmatic use.
+ */
+var component_name_1 = require("./component-name");
+Object.defineProperty(exports, "componentNameFromFilePath", { enumerable: true, get: function () { return component_name_1.componentNameFromFilePath; } });
+var render_1 = require("./commands/render");
+Object.defineProperty(exports, "renderCommand", { enumerable: true, get: function () { return render_1.renderCommand; } });
+var validate_1 = require("./commands/validate");
+Object.defineProperty(exports, "validateCommand", { enumerable: true, get: function () { return validate_1.validateCommand; } });
+var extensions_1 = require("./extensions");
+Object.defineProperty(exports, "buildExtensions", { enumerable: true, get: function () { return extensions_1.buildExtensions; } });
+Object.defineProperty(exports, "frameworkNames", { enumerable: true, get: function () { return extensions_1.frameworkNames; } });
+Object.defineProperty(exports, "stylingNames", { enumerable: true, get: function () { return extensions_1.stylingNames; } });
+var output_1 = require("./output");
+Object.defineProperty(exports, "writeOutputFiles", { enumerable: true, get: function () { return output_1.writeOutputFiles; } });
+var program_1 = require("./program");
+Object.defineProperty(exports, "createProgram", { enumerable: true, get: function () { return program_1.createProgram; } });
+Object.defineProperty(exports, "parseStylingList", { enumerable: true, get: function () { return program_1.parseStylingList; } });
+var template_sources_1 = require("./template-sources");
+Object.defineProperty(exports, "loadTemplate", { enumerable: true, get: function () { return template_sources_1.loadTemplate; } });
+Object.defineProperty(exports, "resolveTemplateSources", { enumerable: true, get: function () { return template_sources_1.resolveTemplateSources; } });

package/dist/output.d.ts

@@ -0,0 +1,11 @@
+import type { OutputFile } from '@js-template-engine/types';
+/**
+ * Writes generated output files under the output directory.
+ *
+ * Directories are created as needed; existing files are overwritten.
+ *
+ * @param files - The files a `process()` call produced.
+ * @param outputDirectory - The directory the files are written into.
+ * @returns The written file paths.
+ */
+export declare function writeOutputFiles(files: OutputFile[], outputDirectory: string): string[];

package/dist/output.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeOutputFiles = writeOutputFiles;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * Writes generated output files under the output directory.
+ *
+ * Directories are created as needed; existing files are overwritten.
+ *
+ * @param files - The files a `process()` call produced.
+ * @param outputDirectory - The directory the files are written into.
+ * @returns The written file paths.
+ */
+function writeOutputFiles(files, outputDirectory) {
+    return files.map((file) => {
+        const filePath = (0, node_path_1.join)(outputDirectory, file.path);
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(filePath), { recursive: true });
+        (0, node_fs_1.writeFileSync)(filePath, file.content);
+        return filePath;
+    });
+}