feat(converter): add typeName for object generation

package.json

@@ -22,6 +22,7 @@
     "start-object:upper": "ts-node ./src/bin/svg-to-ts.ts-object -s 'inputfiles-hyphen/*.svg' -d UPPER",
     "start-object:multiple-source": "ts-node ./src/bin/svg-to-ts-object -s './inputfilesRegex/laughing/laughing.svg' -s 'inputfilesRegex/expressionLess/expressionLess.svg'",
     "start-object:custom": "ts-node ./src/bin/svg-to-ts-object -s './inputfiles/*.svg' -o ./dist --objectName awesomeIcons -f icons",
+    "start-object:generateType": "ts-node ./src/bin/svg-to-ts-object -s './inputfiles/*.svg' -o ./dist --objectName awesomeIcons --typeName MyType",
     "start-object:export-const": "ts-node ./src/bin/svg-to-ts-object.ts -s './inputfiles/*.svg' -o ./dist --objectName myIcons",
     "start-constants": "ts-node ./src/bin/svg-to-ts-constants.ts -s './inputfiles/*.svg'",
     "start-constants:help": "ts-node ./src/bin/svg-to-ts-constants.ts --help'",

src/lib/converters/object.converter.ts

@@ -1,16 +1,23 @@
+import { generateObjectInterface, generateTypeDefinition } from '../generators/code-snippet-generators';
 import { writeFile } from '../helpers/file-helpers';
 import { Logger } from '../helpers/logger';
-import { callAndMonitorAsync } from '../helpers/monitor';
+import { callAndMonitor, callAndMonitorAsync } from '../helpers/monitor';
 import { ObjectConversionOptions } from '../options/conversion-options/object-conversion-options';
 
 import { filesProcessor, SvgDefinition } from './shared.converter';
 
-const generateSVGObject = async (svgDefinitions: SvgDefinition[], objectName: string): Promise<string> => {
+const generateSVGObject = async (
+  svgDefinitions: SvgDefinition[],
+  objectName: string,
+  conversionOptions: ObjectConversionOptions
+): Promise<string> => {
   const svgObject = {};
   svgDefinitions.forEach((svgDefinition: SvgDefinition) => (svgObject[svgDefinition.typeName] = svgDefinition.data));
+  const typePatch = generateObjectInterface(!objectName, conversionOptions);
+
   return !objectName
-    ? `export default ${JSON.stringify(svgObject)}`
-    : `export const ${objectName} = ${JSON.stringify(svgObject)}`;
+    ? `export default ${JSON.stringify(svgObject)}${typePatch}`
+    : `export const ${objectName}${typePatch} = ${JSON.stringify(svgObject)}`;
 };
 
 export const convertToSingleObject = async (conversionOptions: ObjectConversionOptions): Promise<void> => {
@@ -20,9 +27,17 @@ export const convertToSingleObject = async (conversionOptions: ObjectConversionO
     'Processing SVG files'
   );
   const fileContent = await callAndMonitorAsync<string>(
-    generateSVGObject.bind({}, svgDefinitions, objectName),
+    generateSVGObject.bind({}, svgDefinitions, objectName, conversionOptions),
     'Generate SVG Object'
   );
-  await callAndMonitorAsync<void>(writeFile.bind({}, outputDirectory, fileName, fileContent), 'Write content to file');
+  const typeDefinition = callAndMonitor<string>(
+    generateTypeDefinition.bind({}, conversionOptions, svgDefinitions),
+    'Generate type definitions'
+  );
+
+  await callAndMonitorAsync<void>(
+    writeFile.bind({}, outputDirectory, fileName, `${fileContent}${typeDefinition}`),
+    'Write content to file'
+  );
   Logger.generationSuccess(outputDirectory);
 };

src/lib/generators/code-snippet-generators.spec.ts

@@ -9,6 +9,7 @@ import {
   generateEnumDefinition,
   generateInterfaceDefinition,
   generateNamedImportStatement,
+  generateObjectInterface,
   generateSvgConstant,
   generateTypeDefinition,
   generateTypeHelper,
@@ -185,6 +186,23 @@ describe('Generators', () => {
     });
   });
 
+  describe('Object interface generator', () => {
+    it('should generate correct object type if needed', () => {
+      const typeName = 'MockType';
+      const forDefaultExport = generateObjectInterface(true, { typeName, generateType: true });
+      const forConstExport = generateObjectInterface(false, { typeName, generateType: true });
+      expect(forDefaultExport).toEqual(`as { [key in ${typeName}]: string }`);
+      expect(forConstExport).toEqual(`:{ [key in ${typeName}]: string }`);
+    });
+
+    it('should generate empty stirng if not needed', () => {
+      const noTypeName = generateObjectInterface(true, { generateType: true });
+      const noGenerateType = generateObjectInterface(false, { typeName: 'MyType', generateType: false });
+      expect(unformatedString(noTypeName)).toEqual(``);
+      expect(unformatedString(noGenerateType)).toEqual(``);
+    });
+  });
+
   describe('Type helper', () => {
     it('should generate the correct type helper statement', () => {
       const interfaceName = 'MyIcons';

src/lib/generators/code-snippet-generators.ts

@@ -5,6 +5,7 @@ import snakeCase from 'lodash.snakecase';
 import { SvgDefinition } from '../converters/shared.converter';
 import { ConstantsConversionOptions } from '../options/conversion-options/constant-conversion-options';
 import { FilesConversionOptions } from '../options/conversion-options/files-conversion-options';
+import { ObjectConversionOptions } from '../options/conversion-options/object-conversion-options';
 
 export enum Delimiter {
   CAMEL = 'CAMEL',
@@ -38,6 +39,17 @@ export const generateInterfaceDefinition = (conversionOptions: FilesConversionOp
         data: string;}`;
 };
 
+export const generateObjectInterface = (exportAsDefaultObject: boolean, conversionOptions: ObjectConversionOptions) => {
+  const { generateType, typeName } = conversionOptions;
+  const shouldAddTypeInfo = generateType && !!typeName;
+  let typePatch = '';
+  if (shouldAddTypeInfo) {
+    const objectType = `{ [key in ${typeName}]: string }`;
+    typePatch = exportAsDefaultObject ? `as ${objectType}` : `:${objectType}`;
+  }
+  return typePatch;
+};
+
 export const generateTypeDefinition = (
   conversionOptions: FilesConversionOptions | ConstantsConversionOptions,
   svgDefinitions: SvgDefinition[]

src/lib/options/commander/object-options.commander.ts

@@ -26,6 +26,7 @@ export const setupObjectOptionsCommander = () => {
       DEFAULT_OBJECT_CONVERSION_OPTIONS.outputDirectory
     )
     .option('--objectName <string>', 'name of the exported object', DEFAULT_OBJECT_CONVERSION_OPTIONS.objectName)
+    .option('--typeName <string>', 'name of type object to generate', DEFAULT_OBJECT_CONVERSION_OPTIONS.typeName)
     .option('-f --fileName <string>', 'name of the generated file', DEFAULT_OBJECT_CONVERSION_OPTIONS.fileName)
     .option('--svgoConfig <any>', 'Path to svgo configuration JSON or inline svgo configuration object')
     .option(

src/lib/options/conversion-options/object-conversion-options.ts

@@ -9,4 +9,6 @@ export interface ObjectConversionOptions {
   verbose?: boolean;
   fileName?: string;
   objectName?: string;
+  typeName?: string;
+  generateType?: boolean;
 }

src/lib/options/default-options/default-object-conversion-options.ts

@@ -7,5 +7,7 @@ export const DEFAULT_OBJECT_CONVERSION_OPTIONS: ObjectConversionOptions = {
   delimiter: Delimiter.CAMEL,
   verbose: false,
   fileName: 'my-icons',
-  objectName: 'icons'
+  objectName: 'icons',
+  generateType: true,
+  typeName: 'MyType'
 };

src/lib/options/options-collector/command-line-options-collectors/commandline-object-options.collector.ts

@@ -2,14 +2,17 @@ import commander from 'commander';
 
 import { getSvgoConfig } from '../../../helpers/svg-optimization';
 import { ObjectConversionOptions } from '../../conversion-options/object-conversion-options';
+import { DEFAULT_CONST_CONVERSION_OPTIONS } from '../../default-options/default-constants-conversion-options';
 import { DEFAULT_OBJECT_CONVERSION_OPTIONS } from '../../default-options/default-object-conversion-options';
 
 import { toBoolean } from './command-line-collector.helpers';
 
 export const collectCommandLineObjectOptions = async (): Promise<ObjectConversionOptions> => {
-  let { objectName, delimiter, fileName, outputDirectory, verbose } = commander;
+  let { objectName, delimiter, fileName, outputDirectory, verbose, generateType, typeName } = commander;
   let svgoConfig = commander.svgoConfig;
 
+  generateType = toBoolean(generateType, DEFAULT_CONST_CONVERSION_OPTIONS.generateType);
+
   // Parse boolean values
   verbose = toBoolean(verbose, DEFAULT_OBJECT_CONVERSION_OPTIONS.verbose);
 
@@ -26,6 +29,8 @@ export const collectCommandLineObjectOptions = async (): Promise<ObjectConversio
     svgoConfig,
     fileName,
     objectName,
-    verbose
+    verbose,
+    generateType,
+    typeName
   };
 };