type-crafter 0.2.1 → 0.3.0

package/dist/index.js

@@ -10665,6 +10665,17 @@ function __decodeString(value) {
     }
     return errorDelimiter;
 }
+/**
+ * @description A function which attempts to safely cast any value to a valid number
+ * @param value Value with unknown type
+ * @returns Attempts to convert the passed value to a valid number, returns null in case cast fails
+ */
+function decodeNumber(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    return null;
+}
 /**
  * @description A function which attempts to safely cast any value to a valid boolean
  * @param value Value with unknown type
@@ -10809,13 +10820,19 @@ function decodeTypes(rawInput) {
 }
 function decodeTypeInfo(rawInput) {
     if (isJSON(rawInput)) {
+        const _type = decodeTypeDataType(rawInput.type);
         const result = {
-            type: decodeTypeDataType(rawInput.type),
+            type: _type,
             required: decodeArray(rawInput.required, decodeString),
             properties: decodeTypeProperties(rawInput.properties),
             items: decodeTypeInfo(rawInput.items),
             format: decodeString(rawInput.format),
-            $ref: decodeString(rawInput.$ref)
+            $ref: decodeString(rawInput.$ref),
+            enum: _type === 'string'
+                ? decodeArray(rawInput.enum, decodeString)
+                : _type === 'number'
+                    ? decodeArray(rawInput.enum, decodeNumber)
+                    : null
         };
         return result;
     }
@@ -19204,6 +19221,7 @@ let specFileData = null;
 let objectSyntaxTemplate = null;
 let exporterModuleSyntaxTemplate = null;
 let typesFileSyntaxTemplate = null;
+let enumSyntaxTemplate = null;
 let expectedOutputFiles = null;
 function setConfig(newConfig) {
     config$2 = newConfig;
@@ -19228,6 +19246,7 @@ function compileTemplates() {
     objectSyntaxTemplate = Handlebars.compile(config.template.objectSyntax);
     exporterModuleSyntaxTemplate = Handlebars.compile(config.template.exporterModuleSyntax);
     typesFileSyntaxTemplate = Handlebars.compile(config.template.typesFileSyntax);
+    enumSyntaxTemplate = Handlebars.compile(config.template.enumSyntax);
 }
 function getObjectTemplate() {
     if (objectSyntaxTemplate === null) {
@@ -19247,6 +19266,12 @@ function getTypesFileTemplate() {
     }
     return typesFileSyntaxTemplate;
 }
+function getEnumTemplate() {
+    if (enumSyntaxTemplate === null) {
+        throw new RuntimeError('Enum template not compiled!');
+    }
+    return enumSyntaxTemplate;
+}
 function setExpectedOutputFiles(newExpectedOutputFiles) {
     expectedOutputFiles = newExpectedOutputFiles;
 }
@@ -19265,6 +19290,7 @@ var Runtime = {
     getObjectTemplate,
     getExporterModuleTemplate,
     getTypesFileTemplate,
+    getEnumTemplate,
     getExpectedOutputFiles,
     compileTemplates
 };
@@ -19521,7 +19547,7 @@ function getLanguageDataType(dataType, format, items) {
     }
     return dataType;
 }
-function generateType(typeName, typeInfo, groupedTypes = false) {
+function generateObjectType(typeName, typeInfo) {
     const result = {
         content: '',
         references: new Set(),
@@ -19532,11 +19558,14 @@ function generateType(typeName, typeInfo, groupedTypes = false) {
         properties: {}
     };
     let recursiveTypeGenOutput = null;
+    let dynamicGeneratedType = '';
     for (const propertyName in typeInfo.properties) {
-        const propertyType = typeInfo.properties[propertyName].type;
-        const propertyFormat = typeInfo.properties[propertyName].format;
-        const propertyItems = typeInfo.properties[propertyName].items ?? null;
-        const reference = typeInfo.properties[propertyName].$ref ?? null;
+        const propertyDetails = typeInfo.properties[propertyName];
+        const propertyType = propertyDetails.type;
+        const propertyFormat = propertyDetails.format;
+        const propertyItems = propertyDetails.items ?? null;
+        const reference = propertyDetails.$ref ?? null;
+        const enumValues = propertyDetails.enum ?? null;
         // Throwing error in case neither property type nor reference to a different type is present
         if (propertyType === null && reference === null) {
             throw new InvalidSpecFileError('Invalid property type for: ' + typeName + '.' + propertyName);
@@ -19553,9 +19582,14 @@ function generateType(typeName, typeInfo, groupedTypes = false) {
             isReferenced = true;
             result.references.add(recursivePropertyName);
         }
+        else if (enumValues !== null) {
+            const enumName = toPascalCase(propertyName) + 'Enum';
+            dynamicGeneratedType = generateEnumType(enumName, propertyDetails).content;
+            languageDataType = enumName;
+        }
         else if (propertyType === 'object') {
             recursivePropertyName = toPascalCase(propertyName);
-            recursiveTypeGenOutput = generateType(recursivePropertyName, typeInfo.properties[propertyName], groupedTypes);
+            recursiveTypeGenOutput = generateObjectType(recursivePropertyName, typeInfo.properties[propertyName]);
             languageDataType = recursivePropertyName;
             for (const reference of recursiveTypeGenOutput.references.values()) {
                 result.references.add(reference);
@@ -19588,15 +19622,40 @@ function generateType(typeName, typeInfo, groupedTypes = false) {
         };
     }
     result.content =
-        Runtime.getObjectTemplate()(templateInput) + (recursiveTypeGenOutput?.content ?? '');
+        Runtime.getObjectTemplate()(templateInput) +
+            (recursiveTypeGenOutput?.content ?? '') +
+            dynamicGeneratedType;
+    return result;
+}
+function generateEnumType(typeName, typeInfo) {
+    const result = {
+        content: '',
+        references: new Set(),
+        primitives: new Set()
+    };
+    if (typeInfo.enum === null || typeInfo.enum.length === 0 || typeInfo.type === null) {
+        throw new InvalidSpecFileError('Invalid enum type for: ' + typeName);
+    }
+    const templateInput = {
+        enumName: typeName,
+        enumType: typeInfo.type,
+        values: typeInfo.enum
+    };
+    result.content = Runtime.getEnumTemplate()(templateInput);
     return result;
 }
-function generateTypes(types, groupedTypes = false) {
+function generateTypes(types) {
     const result = {};
     for (const type in types) {
         const typeInfo = types[type];
-        const genType = generateType(type, typeInfo);
-        result[type] = genType;
+        const genType = typeInfo.type === 'object'
+            ? generateObjectType(type, typeInfo)
+            : typeInfo.enum !== null
+                ? generateEnumType(type, typeInfo)
+                : null;
+        if (genType !== null) {
+            result[type] = genType;
+        }
     }
     return result;
 }
@@ -19612,7 +19671,7 @@ function generator(specFileData) {
     // generating grouped types
     const groupedTypes = {};
     for (const groupName in specFileData.groupedTypes) {
-        groupedTypes[groupName] = generateTypes(specFileData.groupedTypes[groupName], true);
+        groupedTypes[groupName] = generateTypes(specFileData.groupedTypes[groupName]);
     }
     result.groupedTypes = groupedTypes;
     return result;
@@ -19762,6 +19821,7 @@ async function config$1(inputFilePath, outputDirectory, typesWriterMode, grouped
     const objectSyntax = await readFile(directoryPrefix + 'templates/typescript/object-syntax.hbs', devMode);
     const exporterModuleSyntax = await readFile(directoryPrefix + 'templates/typescript/exporter-module-syntax.hbs', devMode);
     const typesFileSyntax = await readFile(directoryPrefix + 'templates/typescript/types-file-syntax.hbs', devMode);
+    const enumSyntax = await readFile(directoryPrefix + 'templates/typescript/enum-syntax.hbs', devMode);
     const config = {
         input: inputFilePath,
         output: {
@@ -19776,7 +19836,8 @@ async function config$1(inputFilePath, outputDirectory, typesWriterMode, grouped
         template: {
             objectSyntax,
             exporterModuleSyntax,
-            typesFileSyntax
+            typesFileSyntax,
+            enumSyntax
         },
         language: {
             exporterModuleName: 'index',
@@ -19800,6 +19861,7 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
     const objectSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/object-syntax.hbs', devMode);
     const exporterModuleSyntax = await readFile(directoryPrefix + 'templates/typescript/exporter-module-syntax.hbs', devMode);
     const typesFileSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/types-file-syntax.hbs', devMode);
+    const enumSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/enum-syntax.hbs', devMode);
     const config = {
         input: inputFilePath,
         output: {
@@ -19814,7 +19876,8 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
         template: {
             objectSyntax,
             exporterModuleSyntax,
-            typesFileSyntax
+            typesFileSyntax,
+            enumSyntax
         },
         language: {
             exporterModuleName: 'index',
@@ -19879,7 +19942,7 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.2.1');
+const program = new Command().version('0.3.0');
 program
     .command('generate')
     .description('Generate types for your language from a type spec file')

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { Configuration, ExporterModuleTemplateInput, ObjectTemplateInput, SpecFileData, TypeFilePath, TypesFileTemplateInput } from '$types';
+import type { Configuration, EnumTemplateInput, ExporterModuleTemplateInput, ObjectTemplateInput, SpecFileData, TypeFilePath, TypesFileTemplateInput } from '$types';
 declare function setConfig(newConfig: Configuration): void;
 declare function getConfig(): Configuration;
 declare function setSpecFileData(newSpecFileData: SpecFileData): void;
@@ -7,6 +7,7 @@ declare function compileTemplates(): void;
 declare function getObjectTemplate(): HandlebarsTemplateDelegate<ObjectTemplateInput>;
 declare function getExporterModuleTemplate(): HandlebarsTemplateDelegate<ExporterModuleTemplateInput>;
 declare function getTypesFileTemplate(): HandlebarsTemplateDelegate<TypesFileTemplateInput>;
+declare function getEnumTemplate(): HandlebarsTemplateDelegate<EnumTemplateInput>;
 declare function setExpectedOutputFiles(newExpectedOutputFiles: Map<string, TypeFilePath>): void;
 declare function getExpectedOutputFiles(): Map<string, TypeFilePath>;
 declare const _default: {
@@ -18,6 +19,7 @@ declare const _default: {
     getObjectTemplate: typeof getObjectTemplate;
     getExporterModuleTemplate: typeof getExporterModuleTemplate;
     getTypesFileTemplate: typeof getTypesFileTemplate;
+    getEnumTemplate: typeof getEnumTemplate;
     getExpectedOutputFiles: typeof getExpectedOutputFiles;
     compileTemplates: typeof compileTemplates;
 };

package/dist/templates/typescript/enum-syntax.hbs

@@ -0,0 +1,4 @@
+export type {{enumName}} =
+{{#each values}}
+  | {{#if (eq ../enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../enumType 'string')}}'{{/if}}
+{{/each}};

package/dist/templates/typescript-with-decoders/enum-syntax.hbs

@@ -0,0 +1,15 @@
+export type {{enumName}} =
+{{#each values}}
+  | {{#if (eq ../enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../enumType 'string')}}'{{/if}}
+{{/each}};
+
+
+export function decode{{enumName}}(rawInput: unknown): {{enumName}} | null {
+  switch (rawInput) {
+    {{#each values}}
+    case {{#if (eq ../enumType 'string') }}'{{/if}}{{this}}{{#if (eq ../enumType 'string')}}'{{/if}}:
+    {{/each}}
+     return rawInput;
+  }
+  return null;
+}

package/dist/types/decoders.d.ts

@@ -1,5 +1,6 @@
-import type { GroupedTypesWriterMode, ObjectTemplateInputProperties, SpecFileData, TypesWriterMode } from '.';
+import type { EnumTemplateInput, GroupedTypesWriterMode, ObjectTemplateInputProperties, SpecFileData, TypesWriterMode } from '.';
 export declare function decodeGroupedTypesWriterMode(rawInput: unknown): GroupedTypesWriterMode | null;
 export declare function decodeTypesWriterMode(rawInput: unknown): TypesWriterMode | null;
 export declare function decodeSpecFileData(rawInput: unknown): SpecFileData | null;
 export declare function decodeObjectTemplateInputProperties(rawInput: unknown): ObjectTemplateInputProperties | null;
+export declare function decodeEnumTemplateInput(rawInput: unknown): EnumTemplateInput | null;

package/dist/types/index.d.ts

@@ -20,6 +20,7 @@ export type Template = {
     objectSyntax: string;
     exporterModuleSyntax: string;
     typesFileSyntax: string;
+    enumSyntax: string;
 };
 export type LanguageConfig = {
     exporterModuleName: string;
@@ -54,6 +55,7 @@ export type TypeInfo = {
     items: TypeInfo | null;
     properties: TypeProperties | null;
     $ref: string | null;
+    enum: string[] | number[] | null;
 };
 type PropertyName = string;
 export type TypeProperties = Record<PropertyName, TypeInfo>;
@@ -84,6 +86,11 @@ export type ReferencedModule = {
     moduleRelativePath: string;
     referencedTypes: string[];
 };
+export type EnumTemplateInput = {
+    enumName: string;
+    enumType: string;
+    values: string[] | number[];
+};
 export type GenerationResult = {
     groupedTypes: GroupedTypesOutput;
     types: GeneratedTypes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-crafter",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "A tool to generate types from a yaml schema for any language",
   "main": "./dist/index.js",
   "type": "module",