90 ts non const enum option (#91)

Author: cuzfrog

annotation/src/main/java/online/sharedtype/SharedType.java

@@ -160,7 +160,7 @@
 
     /**
      * Format of enum in Typescript.
-     * @return either "union" (union types) or "const_enum" (const enum). If empty, fallback to global default.
+     * @return one of "const_enum" (const enum), "enum" (enum), or "union" (union types). If empty, fallback to global default.
      */
     String typescriptEnumFormat() default "";
 

doc/Usage.md

@@ -82,7 +82,7 @@ You can customize the path by config `maven-compiler-plugin`:
 See [Default Properties](../processor/src/main/resources/sharedtype-default.properties) for details.
 
 #### Per annotation options
-See Javadoc on [@SharedType](../annotation/src/main/java/online/sharedtype/annotation/SharedType.java) for details.
+See Javadoc on [@SharedType](../annotation/src/main/java/online/sharedtype/SharedType.java) for details.
 
 ### Limitations
 * Current design only retain `@SharedType` on source level. That means they are not visible if it is in a dependency jar during its dependent's compilation.

it/java8/src/main/java/online/sharedtype/it/java8/EnumTShirt.java

@@ -3,7 +3,7 @@
 import lombok.Getter;
 import online.sharedtype.SharedType;
 
-@SharedType(typescriptEnumFormat = "const_enum")
+@SharedType(typescriptEnumFormat = "enum")
 @Getter
 public enum EnumTShirt {
     S(EnumSize.SMALL, "S"),

it/java8/src/main/java/online/sharedtype/it/java8/TempClass.java

@@ -1,5 +1,9 @@
 package online.sharedtype.it.java8;
 
-public class TempClass {
+import online.sharedtype.SharedType;
+
+import java.time.LocalDate;
 
+public class TempClass {
+    LocalDate localDate;
 }

processor/src/main/java/online/sharedtype/processor/context/Config.java

@@ -67,38 +67,41 @@ private static boolean evaluateOptionalBool(SharedType.OptionalBool optionalBool
         }
     }
 
-    private static Set<Props.Typescript.OptionalFieldFormat> parseTsOptionalFieldFormats(SharedType anno, Context ctx) {
+    private Set<Props.Typescript.OptionalFieldFormat> parseTsOptionalFieldFormats(SharedType anno, Context ctx) {
         if (anno.typescriptOptionalFieldFormat().length > 0) {
             List<String> values = Arrays.asList(anno.typescriptOptionalFieldFormat());
             try {
                 return EnumParsingUtils.parseEnumSet(values, Props.Typescript.OptionalFieldFormat.class, Props.Typescript.OptionalFieldFormat::fromString);
             } catch (IllegalArgumentException e) {
                 throw new SharedTypeException(String.format(
-                    "Invalid value for SharedType.typescriptOptionalFieldFormat: %s, only '?', 'null', 'undefined' are allowed.", values), e);
+                    "Invalid value for SharedType.typescriptOptionalFieldFormat: %s, only '?', 'null', 'undefined' are allowed. " +
+                        "When parsing annotation for '%s'.", values, qualifiedName), e);
             }
         }
         return ctx.getProps().getTypescript().getOptionalFieldFormats();
     }
 
-    private static Props.Typescript.EnumFormat parseTsEnumFormat(SharedType anno, Context ctx) {
+    private Props.Typescript.EnumFormat parseTsEnumFormat(SharedType anno, Context ctx) {
         if (anno.typescriptEnumFormat() != null && !anno.typescriptEnumFormat().isEmpty()) {
             try {
                 return Props.Typescript.EnumFormat.fromString(anno.typescriptEnumFormat());
             } catch (IllegalArgumentException e) {
                 throw new SharedTypeException(String.format(
-                    "Invalid value for SharedType.typescriptEnumFormat: '%s', only 'union' or 'const_enum' is allowed.", anno.typescriptEnumFormat()), e);
+                    "Invalid value for SharedType.typescriptEnumFormat: '%s', only one of 'union', 'const_enum', 'enum' is allowed. " +
+                        "When parsing annotation for '%s'.", anno.typescriptEnumFormat(), qualifiedName), e);
             }
         }
         return ctx.getProps().getTypescript().getEnumFormat();
     }
 
-    private static Props.Typescript.FieldReadonlyType parseTsFieldReadonlyType(SharedType anno, Context ctx) {
+    private Props.Typescript.FieldReadonlyType parseTsFieldReadonlyType(SharedType anno, Context ctx) {
         if (anno.typescriptFieldReadonlyType() != null && !anno.typescriptFieldReadonlyType().isEmpty()) {
             try {
                 return Props.Typescript.FieldReadonlyType.fromString(anno.typescriptFieldReadonlyType());
             } catch (IllegalArgumentException e) {
                 throw new SharedTypeException(String.format(
-                    "Invalid value for SharedType.typescriptFieldReadonlyType: '%s', only 'all', 'acyclic', 'none' is allowed.", anno.typescriptFieldReadonlyType()), e);
+                    "Invalid value for SharedType.typescriptFieldReadonlyType: '%s', only 'all', 'acyclic', 'none' is allowed. " +
+                        "When parsing annotation for '%s'.", anno.typescriptFieldReadonlyType(), qualifiedName), e);
             }
         }
         return ctx.getProps().getTypescript().getFieldReadonlyType();

processor/src/main/java/online/sharedtype/processor/context/Props.java

@@ -59,7 +59,7 @@ public static OptionalFieldFormat fromString(String value) {
         }
 
         public enum EnumFormat {
-            UNION, CONST_ENUM,
+            UNION, CONST_ENUM, ENUM,
             ;
             public static EnumFormat fromString(String value) {
                 return EnumFormat.valueOf(value.toUpperCase());

processor/src/main/java/online/sharedtype/processor/writer/converter/TypescriptEnumConverter.java

@@ -34,23 +34,24 @@ public Tuple<Template, Object> convert(TypeDef typeDef) {
                 values.add(ConversionUtils.literalValue(component.value()));
             }
             return Tuple.of(Template.TEMPLATE_TYPESCRIPT_UNION_TYPE_ENUM, new EnumUnionExpr(enumDef.simpleName(), values));
-        } else if (config.getTypescriptEnumFormat() == Props.Typescript.EnumFormat.CONST_ENUM) {
+        } else {
             EnumExpr value = new EnumExpr(
                 enumDef.simpleName(),
+                config.getTypescriptEnumFormat() == Props.Typescript.EnumFormat.CONST_ENUM,
                 enumDef.components().stream().map(component -> new EnumValueExpr(
                     component.name(),
                     ConversionUtils.literalValue(component.value())
                 )).collect(Collectors.toList())
             );
-            return Tuple.of(Template.TEMPLATE_TYPESCRIPT_CONST_ENUM, value);
+            return Tuple.of(Template.TEMPLATE_TYPESCRIPT_ENUM, value);
         }
-        throw new SharedTypeInternalError("Unknown typescript enum format: " + config.getTypescriptEnumFormat());
     }
 
     @SuppressWarnings("unused")
     @RequiredArgsConstructor
     static final class EnumExpr {
         final String name;
+        final boolean isConst;
         final List<EnumValueExpr> values;
     }
 

processor/src/main/java/online/sharedtype/processor/writer/render/Template.java

@@ -15,7 +15,7 @@ public final class Template {
     public static final Template TEMPLATE_TYPESCRIPT_HEADER = new Template(OutputTarget.TYPESCRIPT, "header");
     public static final Template TEMPLATE_TYPESCRIPT_INTERFACE = new Template(OutputTarget.TYPESCRIPT, "interface");
     public static final Template TEMPLATE_TYPESCRIPT_UNION_TYPE_ENUM = new Template(OutputTarget.TYPESCRIPT, "union-type-enum");
-    public static final Template TEMPLATE_TYPESCRIPT_CONST_ENUM = new Template(OutputTarget.TYPESCRIPT, "const-enum");
+    public static final Template TEMPLATE_TYPESCRIPT_ENUM = new Template(OutputTarget.TYPESCRIPT, "enum");
     public static final Template TEMPLATE_RUST_HEADER = new Template(OutputTarget.RUST, "header");
     public static final Template TEMPLATE_RUST_STRUCT = new Template(OutputTarget.RUST, "struct");
     public static final Template TEMPLATE_RUST_ENUM = new Template(OutputTarget.RUST, "enum");

processor/src/main/resources/sharedtype-default.properties

@@ -51,7 +51,7 @@ sharedtype.typescript.interface-property-delimiter=;
 ## optional field format, can be combination of "?", "null", "undefined", the latter 2 are rendered as union type. Cannot be empty.
 sharedtype.typescript.optional-field-format=?
 
-## enum format, can be "const_enum" (const enum) or "union" (union type).
+## enum format, can be "const_enum" (const enum), "enum" (enum), or "union" (union type).
 sharedtype.typescript.enum-format=union
 
 ## whether to mark field as readonly, value can be one of:

…templates/typescript/const-enum.mustache …urces/templates/typescript/enum.mustacheprocessor/src/main/resources/templates/typescript/const-enum.mustache renamed to processor/src/main/resources/templates/typescript/enum.mustache processor/src/main/resources/templates/typescript/const-enum.mustache renamed to processor/src/main/resources/templates/typescript/enum.mustache

@@ -1,4 +1,4 @@
-export const enum {{name}} {
+export {{#isConst}}const {{/isConst}}enum {{name}} {
 {{#values}}
     {{name}} = {{{value}}},
 {{/values}}