Support non-ascii (unicode) enum and type names.

This replaces regexp patterns that only worked with ascii characters with more proper matching that supports unicode identifiers in typescript/javascript.

The platform must support "unicode-aware mode" (the u flag) for this to work. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicode

Author: josstn

src/openApi/v2/parser/escapeName.ts

@@ -1,6 +1,8 @@
+import validTypescriptIdentifierRegex from '../../../utils/validTypescriptIdentifierRegex';
+
 export const escapeName = (value: string): string => {
     if (value || value === '') {
-        const validName = /^[a-zA-Z_$][\w$]+$/g.test(value);
+        const validName = validTypescriptIdentifierRegex.test(value);
         if (!validName) {
             return `'${value}'`;
         }

src/openApi/v2/parser/getEnum.ts

@@ -1,4 +1,5 @@
 import type { Enum } from '../../../client/interfaces/Enum';
+import sanitizeEnumName from '../../../utils/sanitizeEnumName';
 
 export const getEnum = (values?: (string | number)[]): Enum[] => {
     if (Array.isArray(values)) {
@@ -19,11 +20,7 @@ export const getEnum = (values?: (string | number)[]): Enum[] => {
                     };
                 }
                 return {
-                    name: String(value)
-                        .replace(/\W+/g, '_')
-                        .replace(/^(\d+)/g, '_$1')
-                        .replace(/([a-z])([A-Z]+)/g, '$1_$2')
-                        .toUpperCase(),
+                    name: sanitizeEnumName(String(value)),
                     value: `'${value.replace(/'/g, "\\'")}'`,
                     type: 'string',
                     description: null,

src/openApi/v2/parser/getType.ts

@@ -1,10 +1,9 @@
 import type { Type } from '../../../client/interfaces/Type';
+import sanitizeTypeName from '../../../utils/sanitizeTypeName';
 import { getMappedType } from './getMappedType';
 import { stripNamespace } from './stripNamespace';
 
-const encode = (value: string): string => {
-    return value.replace(/^[^a-zA-Z_$]+/g, '').replace(/[^\w$]+/g, '_');
-};
+const encode = (value: string): string => sanitizeTypeName(value);
 
 /**
  * Parse any string value into a type object.

src/openApi/v3/parser/escapeName.ts

@@ -1,6 +1,8 @@
+import validTypescriptIdentifierRegex from '../../../utils/validTypescriptIdentifierRegex';
+
 export const escapeName = (value: string): string => {
     if (value || value === '') {
-        const validName = /^[a-zA-Z_$][\w$]+$/g.test(value);
+        const validName = validTypescriptIdentifierRegex.test(value);
         if (!validName) {
             return `'${value}'`;
         }

src/openApi/v3/parser/getEnum.ts

@@ -1,4 +1,5 @@
 import type { Enum } from '../../../client/interfaces/Enum';
+import sanitizeEnumName from '../../../utils/sanitizeEnumName';
 
 export const getEnum = (values?: (string | number)[]): Enum[] => {
     if (Array.isArray(values)) {
@@ -19,11 +20,7 @@ export const getEnum = (values?: (string | number)[]): Enum[] => {
                     };
                 }
                 return {
-                    name: String(value)
-                        .replace(/\W+/g, '_')
-                        .replace(/^(\d+)/g, '_$1')
-                        .replace(/([a-z])([A-Z]+)/g, '$1_$2')
-                        .toUpperCase(),
+                    name: sanitizeEnumName(String(value)),
                     value: `'${value.replace(/'/g, "\\'")}'`,
                     type: 'string',
                     description: null,

src/openApi/v3/parser/getType.ts

@@ -1,11 +1,10 @@
 import type { Type } from '../../../client/interfaces/Type';
 import { isDefined } from '../../../utils/isDefined';
+import sanitizeTypeName from '../../../utils/sanitizeTypeName';
 import { getMappedType } from './getMappedType';
 import { stripNamespace } from './stripNamespace';
 
-const encode = (value: string): string => {
-    return value.replace(/^[^a-zA-Z_$]+/g, '').replace(/[^\w$]+/g, '_');
-};
+const encode = (value: string): string => sanitizeTypeName(value);
 
 /**
  * Parse any string value into a type object.

src/utils/sanitizeEnumName.spec.ts

@@ -0,0 +1,11 @@
+import sanitizeEnumName from './sanitizeEnumName';
+
+describe('sanitizeEnumName', () => {
+    it('should replace illegal characters', () => {
+        expect(sanitizeEnumName('abc')).toEqual('ABC');
+        expect(sanitizeEnumName('æbc')).toEqual('ÆBC');
+        expect(sanitizeEnumName('æb.c')).toEqual('ÆB_C');
+        expect(sanitizeEnumName('1æb.c')).toEqual('_1ÆB_C');
+        expect(sanitizeEnumName("'quoted'")).toEqual('_QUOTED_');
+    });
+});

src/utils/sanitizeEnumName.ts

@@ -0,0 +1,18 @@
+/**
+ * Sanitizes names of enums, so they are valid typescript identifiers of a certain form.
+ *
+ * 1: Replace all characters not legal as part of identifier with '_'
+ * 2: Add '_' prefix if first character of enum name has character not legal for start of identifier
+ * 3: Add '_' where the string transitions from lowercase to uppercase
+ * 4: Transform the whole string to uppercase
+ *
+ * Javascript identifier regexp pattern retrieved from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers
+ */
+const sanitizeEnumName = (name: string) =>
+    name
+        .replace(/[^$\u200c\u200d\p{ID_Continue}]/gu, '_')
+        .replace(/^([^$_\p{ID_Start}])/u, '_$1')
+        .replace(/(\p{Lowercase})(\p{Uppercase}+)/gu, '$1_$2')
+        .toUpperCase();
+
+export default sanitizeEnumName;

src/utils/sanitizeTypeName.spec.ts

@@ -0,0 +1,10 @@
+import sanitizeTypeName from './sanitizeTypeName';
+
+describe('sanitizeTypeName', () => {
+    it('should remove/replace illegal characters', () => {
+        expect(sanitizeTypeName('abc')).toEqual('abc');
+        expect(sanitizeTypeName('æbc')).toEqual('æbc');
+        expect(sanitizeTypeName('æb.c')).toEqual('æb_c');
+        expect(sanitizeTypeName('1æb.c')).toEqual('æb_c');
+    });
+});

src/utils/sanitizeTypeName.ts

@@ -0,0 +1,16 @@
+/**
+ * Sanitizes names of types, so they are valid typescript identifiers of a certain form.
+ *
+ * 1: Remove any leading characters that are illegal as starting character of a typescript identifier.
+ * 2: Replace illegal characters in remaining part of type name with underscore (_).
+ *
+ * Step 1 should perhaps instead also replace illegal characters with underscore, or prefix with it, like sanitizeEnumName
+ * does. The way this is now one could perhaps end up removing all characters, if all are illegal start characters. It
+ * would be sort of a breaking change to do so, though, previously generated code might change then.
+ *
+ * Javascript identifier regexp pattern retrieved from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers
+ */
+const sanitizeTypeName = (name: string) =>
+    name.replace(/^[^$_\p{ID_Start}]+/u, '').replace(/[^$\u200c\u200d\p{ID_Continue}]/gu, '_');
+
+export default sanitizeTypeName;