22 ts const enum (#84)

* Add option for ts enum format
* Render ts const enum

Author: cuzfrog

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

@@ -159,6 +159,12 @@
      */
     String[] typescriptOptionalFieldFormat() default {};
 
+    /**
+     * Format of enum in Typescript.
+     * @return either "union" (union types) or "const_enum" (const enum). If empty, fallback to global default.
+     */
+    String typescriptEnumFormat() default "";
+
     /**
      * Mark a method as an accessor regardless of its name.
      * Getter prefixes are configured in global properties.

client-test/typescript/src/types.java17.ts

@@ -1,6 +1,6 @@
 import {
     type DependencyClassA, type DependencyClassB, type DependencyClassC, type EnumGalaxy, type EnumSize,
-    type EnumTShirt, type JavaRecord, type AnotherJavaClass, type RecursiveClass, type MapClass,
+    EnumTShirt, type JavaRecord, type AnotherJavaClass, type RecursiveClass, type MapClass,
     type OptionalMethod,
 } from "./index.java17";
 
@@ -11,6 +11,7 @@ export const record1: Record<EnumTShirt, number> = {
     L: 3,
 }
 export const size1: EnumSize = 1;
+export const tshirtSize1: EnumTShirt = EnumTShirt.S;
 
 export const dependencyClassC: DependencyClassC = {
 };

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

@@ -3,7 +3,10 @@
 import lombok.RequiredArgsConstructor;
 import online.sharedtype.SharedType;
 
-@SharedType(rustMacroTraits = {"PartialEq", "Eq", "Hash", "serde::Serialize", "serde::Deserialize"})
+@SharedType(
+    rustMacroTraits = {"PartialEq", "Eq", "Hash", "serde::Serialize", "serde::Deserialize"},
+    typescriptEnumFormat = "const_enum"
+)
 @RequiredArgsConstructor
 public enum EnumSize {
     SMALL(1), MEDIUM(2), LARGE(3);

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

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

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

@@ -12,6 +12,7 @@
 import java.util.EnumSet;
 import java.util.List;
 import java.util.Set;
+import java.util.function.Function;
 
 /**
  * Config wrappers.
@@ -30,6 +31,8 @@ public final class Config {
     private final boolean constantNamespaced;
     @Getter
     private final Set<Props.Typescript.OptionalFieldFormat> typescriptOptionalFieldFormats;
+    @Getter
+    private final Props.Typescript.EnumFormat typescriptEnumFormat;
 
     @Retention(RetentionPolicy.RUNTIME)
     @interface AnnoContainer {
@@ -50,6 +53,7 @@ public Config(TypeElement typeElement, Context ctx) {
         this.includedComponentTypes = includedCompTypes.isEmpty() ? Collections.emptySet() : EnumSet.copyOf(includedCompTypes);
         constantNamespaced = evaluateOptionalBool(anno.constantNamespaced(), ctx.getProps().isConstantNamespaced());
         typescriptOptionalFieldFormats = parseTsOptionalFieldFormats(anno, ctx);
+        typescriptEnumFormat = parseTsEnumFormat(anno, ctx);
     }
 
     public boolean includes(SharedType.ComponentType componentType) {
@@ -69,16 +73,26 @@ private static boolean evaluateOptionalBool(SharedType.OptionalBool optionalBool
 
     private static Set<Props.Typescript.OptionalFieldFormat> parseTsOptionalFieldFormats(SharedType anno, Context ctx) {
         if (anno.typescriptOptionalFieldFormat().length > 0) {
-            EnumSet<Props.Typescript.OptionalFieldFormat> formats = EnumSet.noneOf(Props.Typescript.OptionalFieldFormat.class);
-            for (String value : anno.typescriptOptionalFieldFormat()) {
-                try {
-                    formats.add(Props.Typescript.OptionalFieldFormat.fromString(value));
-                } catch (IllegalArgumentException e) {
-                    throw new SharedTypeException(String.format("Invalid value for SharedType.typescriptOptionalFieldFormat: '%s', only '?', 'null', 'undefined' are allowed.", value), e);
-                }
+            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);
             }
-            return formats;
         }
         return ctx.getProps().getTypescript().getOptionalFieldFormats();
     }
+
+    private static 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);
+            }
+        }
+        return ctx.getProps().getTypescript().getEnumFormat();
+    }
 }

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

@@ -0,0 +1,19 @@
+package online.sharedtype.processor.context;
+
+import lombok.experimental.UtilityClass;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Set;
+import java.util.function.Function;
+
+@UtilityClass
+final class EnumParsingUtils {
+    static <T extends Enum<T>> Set<T> parseEnumSet(Collection<String> values, Class<T> type, Function<String, T> enumValueOf) {
+        Set<T> set = EnumSet.noneOf(type);
+        for (String trimmed : values) {
+            set.add(enumValueOf.apply(trimmed));
+        }
+        return set;
+    }
+}

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

@@ -35,6 +35,7 @@ public static final class Typescript {
         private final char interfacePropertyDelimiter;
         private final String javaObjectMapType;
         private final Set<OptionalFieldFormat> optionalFieldFormats;
+        private final EnumFormat enumFormat;
 
         @Getter
         public enum OptionalFieldFormat {
@@ -55,6 +56,14 @@ public static OptionalFieldFormat fromString(String value) {
                 throw new IllegalArgumentException(String.format("Unknown optional field format: '%s', only '?', 'null', 'undefined' are allowed", value));
             }
         }
+
+        public enum EnumFormat {
+            UNION, CONST_ENUM,
+            ;
+            public static EnumFormat fromString(String value) {
+                return EnumFormat.valueOf(value.toUpperCase());
+            }
+        }
     }
 
     @Builder(access = AccessLevel.PACKAGE)

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

@@ -6,7 +6,6 @@
 import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.EnumSet;
 import java.util.LinkedHashSet;
 import java.util.Properties;
 import java.util.Set;
@@ -54,8 +53,9 @@ private static Props loadProps(Properties properties) {
                 .outputFileName(properties.getProperty("sharedtype.typescript.output-file-name"))
                 .interfacePropertyDelimiter(properties.getProperty("sharedtype.typescript.interface-property-delimiter").charAt(0))
                 .javaObjectMapType(properties.getProperty("sharedtype.typescript.java-object-map-type"))
-                .optionalFieldFormats(parseEnumSet(properties,"sharedtype.typescript.optional-field-format",
+                .optionalFieldFormats(parseEnumSet(properties, "sharedtype.typescript.optional-field-format",
                     Props.Typescript.OptionalFieldFormat.class, Props.Typescript.OptionalFieldFormat::fromString))
+                .enumFormat(parseEnum(properties, "sharedtype.typescript.enum-format", Props.Typescript.EnumFormat::fromString))
                 .build())
             .rust(Props.Rust.builder()
                 .outputFileName(properties.getProperty("sharedtype.rust.output-file-name"))
@@ -68,15 +68,11 @@ private static Props loadProps(Properties properties) {
 
     private static <T extends Enum<T>> Set<T> parseEnumSet(Properties properties, String propertyName, Class<T> type, Function<String, T> enumValueOf) {
         Set<String> trimmedElems = splitArray(properties.getProperty(propertyName));
-        Set<T> set = EnumSet.noneOf(type);
         try {
-            for (String trimmed : trimmedElems) {
-                set.add(enumValueOf.apply(trimmed));
-            }
+            return EnumParsingUtils.parseEnumSet(trimmedElems, type, enumValueOf);
         } catch (Exception e) {
             throw new IllegalArgumentException(String.format("Failed to parse property '%s'", propertyName), e);
         }
-        return set;
     }
 
     private static Set<String> splitArray(String value) {
@@ -99,7 +95,7 @@ private static boolean parseBoolean(Properties properties, String key) {
         if ("false".equals(value)) {
             return false;
         }
-        throw new SharedTypeException(String.format("property '%s', can only be 'true' or 'false'.", key));
+        throw new IllegalArgumentException(String.format("property '%s', can only be 'true' or 'false'.", key));
     }
 
     private static <T> Set<Class<? extends T>> parseClassSet(Properties properties, String propertyName) {
@@ -110,12 +106,21 @@ private static <T> Set<Class<? extends T>> parseClassSet(Properties properties,
             try {
                 annotations.add(parseClass(propertyValue));
             } catch (ClassNotFoundException e) {
-                throw new SharedTypeException(String.format("Invalid property %s=%s", propertyName, value), e);
+                throw new IllegalArgumentException(String.format("Invalid property %s=%s", propertyName, value), e);
             }
         }
         return annotations;
     }
 
+    private static <T extends Enum<T>> T parseEnum(Properties properties, String propertyName, Function<String, T> fromString) {
+        String value = properties.getProperty(propertyName);
+        try {
+            return fromString.apply(value);
+        } catch (Exception e) {
+            throw new IllegalArgumentException(String.format("Invalid property %s=%s", propertyName, value), e);
+        }
+    }
+
     @SuppressWarnings("unchecked")
     private static <T> Class<? extends T> parseClass(String className) throws ClassNotFoundException {
         return (Class<? extends T>) Class.forName(className);

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

@@ -19,7 +19,7 @@ public interface TemplateDataConverter {
     static Set<TemplateDataConverter> typescript(Context ctx) {
         Set<TemplateDataConverter> converters = new HashSet<>(3);
         converters.add(new TypescriptInterfaceConverter(ctx, TypeExpressionConverter.typescript(ctx)));
-        converters.add(new TypescriptEnumUnionConverter());
+        converters.add(new TypescriptEnumConverter(ctx));
         converters.add(new ConstantConverter(ctx, null, OutputTarget.TYPESCRIPT));
         return converters;
     }