feat(compiler): compile ts files

src/lib/compiler/typescript-compiler.ts

@@ -0,0 +1,35 @@
+import * as ts from 'typescript';
+
+const compile = (filePaths: string[], compilerOptions: ts.CompilerOptions): void => {
+  let program = ts.createProgram(filePaths, compilerOptions);
+  let emitResult = program.emit();
+
+  reportDiagnostics(ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics));
+
+  let exitCode = emitResult.emitSkipped ? 1 : 0;
+  process.exit(exitCode);
+};
+
+function reportDiagnostics(diagnostics: ts.Diagnostic[]): void {
+  diagnostics.forEach(diagnostic => {
+    let message = 'Error';
+    if (diagnostic.file) {
+      let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+      message += ` ${diagnostic.file.fileName} (${line + 1},${character + 1})`;
+    }
+    message += ': ' + ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    console.log(message);
+  });
+}
+
+export const compileSources = (filePaths: string[]): void => {
+  const tsOptions = {
+    noEmitOnError: true,
+    noImplicitAny: true,
+    declaration: true,
+    moduleResolution: ts.ModuleResolutionKind.NodeJs,
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext
+  };
+  compile(filePaths, tsOptions);
+};

src/lib/converters/multiple-files.converter.ts

@@ -7,21 +7,22 @@ import {
   generateSvgConstant,
   generateTypeDefinition,
   generateTypeName,
+  generateUntypedSvgConstant,
   generateVariableName
 } from '../generators/generators';
-import { getFilePathsFromRegex } from '../regex-helpers';
-import { extractSvgContent, writeIconsFile } from '../file-helpers';
+import { getFilePathsFromRegex } from '../helpers/regex-helpers';
+import { deleteFolder, extractSvgContent, writeIconsFile } from '../helpers/file-helpers';
 import { ConvertionOptions } from '../../bin/svg-to-ts';
+import { compileSources } from '../compiler/typescript-compiler';
 
 const typesDelimitor = ' | ';
 
 export const convertToMultipleFiles = async (convertionOptions: ConvertionOptions): Promise<void> => {
   const { typeName, prefix, delimiter, interfaceName, outputDirectory, srcFiles, fileName } = convertionOptions;
-  let svgConstants = '';
-  let types = generateTypeDefinition(typeName);
 
   try {
     const filePaths = await getFilePathsFromRegex(srcFiles);
+    await deleteFolder(`${outputDirectory}/icons`);
     for (let i = 0; i < filePaths.length; i++) {
       const fileNameWithEnding = path.basename(filePaths[i]);
       const [filenameWithoutEnding, extension] = fileNameWithEnding.split('.');
@@ -31,26 +32,25 @@ export const convertToMultipleFiles = async (convertionOptions: ConvertionOption
         const optimizedSvg = await svgo.optimize(rawSvg);
         const variableName = generateVariableName(prefix, filenameWithoutEnding);
         const typeName = generateTypeName(filenameWithoutEnding, delimiter);
-        const svgConstant = generateSvgConstant(variableName, interfaceName, typeName, optimizedSvg.data);
+        const svgConstant = generateUntypedSvgConstant(variableName, typeName, optimizedSvg.data);
 
-        await writeIconsFile(outputDirectory, `${prefix}-${filenameWithoutEnding}.icon`, svgConstant);
-
-        svgConstants += svgConstant;
-        types += i === filePaths.length - 1 ? `'${typeName}';` : `'${typeName}'${typesDelimitor}`;
+        await writeIconsFile(`${outputDirectory}/icons`, `${prefix}-${filenameWithoutEnding}.icon`, svgConstant);
       }
     }
+    const outputFiles = await getFilePathsFromRegex([`${outputDirectory}/icons/*.ts`]);
+    compileSources(outputFiles);
 
     /*
-        if (svgConstants !== '') {
-            const fileContent = (svgConstants += types += generateInterfaceDefinition(interfaceName, typeName));
-            await writeIconsFile(outputDirectory, fileName, fileContent);
-            console.log(
-                chalk.blue.bold('svg-to-ts:'),
-                chalk.green('Icons file successfully generated under'),
-                chalk.green.underline(outputDirectory)
-            );
-        }
-         */
+            if (svgConstants !== '') {
+                const fileContent = (svgConstants += types += generateInterfaceDefinition(interfaceName, typeName));
+                await writeIconsFile(outputDirectory, fileName, fileContent);
+                console.log(
+                    chalk.blue.bold('svg-to-ts:'),
+                    chalk.green('Icons file successfully generated under'),
+                    chalk.green.underline(outputDirectory)
+                );
+            }
+             */
   } catch (error) {
     console.log(chalk.blue.bold('svg-to-ts:'), chalk.red('Something went wrong', error));
   }

src/lib/generators/generators.ts

@@ -30,6 +30,29 @@ export const generateSvgConstant = (
             };`;
 };
 
+export const generateUntypedSvgConstant = (
+  variableName: string,
+  filenameWithoutEnding: string,
+  data: string
+): string => {
+  return `export const ${variableName} = {
+                name: '${filenameWithoutEnding}',
+                data: '${data}'
+            };`;
+};
+
+export const generateSvgStandaloneFile = (
+  variableName: string,
+  interfaceName: string,
+  filenameWithoutEnding: string,
+  data: string
+): string => {
+  return `export const ${variableName}: ${interfaceName} = {
+                name: '${filenameWithoutEnding}',
+                data: '${data}'
+            };`;
+};
+
 export const generateTypeName = (filenameWithoutEnding, delimiter: Delimiter): string => {
   if (delimiter === Delimiter.CAMEL) {
     return `${camelCase(filenameWithoutEnding)}`;

src/lib/file-helpers.ts → src/lib/helpers/file-helpers.ts

@@ -4,8 +4,6 @@ import * as path from 'path';
 import * as prettier from 'prettier/standalone';
 import typescriptParser from 'prettier/parser-typescript';
 
-import { ConvertionOptions } from '../bin/svg-to-ts';
-
 const readfile = util.promisify(fs.readFile);
 const writeFile = util.promisify(fs.writeFile);
 
@@ -17,11 +15,25 @@ export const extractSvgContent = async (filePath: string): Promise<string> => {
 export const writeIconsFile = async (outputDirectory: string, fileName: string, fileContent: string): Promise<void> => {
   const formatedFileContent = formatContent(fileContent);
   if (!fs.existsSync(outputDirectory)) {
-    fs.mkdirSync(outputDirectory);
+    fs.mkdirSync(outputDirectory, { recursive: true });
   }
   await writeFile(path.join(outputDirectory, `${fileName}.ts`), formatedFileContent);
 };
 
+export const deleteFolder = async (directoryPath: string) => {
+  if (fs.existsSync(directoryPath)) {
+    fs.readdirSync(directoryPath).forEach((filePath: string) => {
+      const curPath = directoryPath + '/' + filePath;
+      if (fs.lstatSync(curPath).isDirectory()) {
+        deleteFolder(curPath);
+      } else {
+        fs.unlinkSync(curPath);
+      }
+    });
+    fs.rmdirSync(directoryPath);
+  }
+};
+
 const formatContent = (fileContent: string) =>
   prettier.format(fileContent, {
     parser: 'typescript',