Non ascii character support

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/getOperationName.ts

@@ -1,18 +1,15 @@
 import camelCase from 'camelcase';
 
+import sanitizeOperationName from '../../../utils/sanitizeOperationName';
+
 /**
  * Convert the input value to a correct operation (method) classname.
  * This will use the operation ID - if available - and otherwise fallback
  * on a generated name from the URL
  */
 export const getOperationName = (url: string, method: string, operationId?: string): string => {
     if (operationId) {
-        return camelCase(
-            operationId
-                .replace(/^[^a-zA-Z]+/g, '')
-                .replace(/[^\w\-]+/g, '-')
-                .trim()
-        );
+        return camelCase(sanitizeOperationName(operationId).trim());
     }
 
     const urlWithoutPlaceholders = url

src/openApi/v2/parser/getOperationParameterName.ts

@@ -1,15 +1,13 @@
 import camelCase from 'camelcase';
 
 import { reservedWords } from '../../../utils/reservedWords';
+import sanitizeOperationParameterName from '../../../utils/sanitizeOperationParameterName';
 
 /**
  * Replaces any invalid characters from a parameter name.
  * For example: 'filter.someProperty' becomes 'filterSomeProperty'.
  */
 export const getOperationParameterName = (value: string): string => {
-    const clean = value
-        .replace(/^[^a-zA-Z]+/g, '')
-        .replace(/[^\w\-]+/g, '-')
-        .trim();
+    const clean = sanitizeOperationParameterName(value).trim();
     return camelCase(clean).replace(reservedWords, '_$1');
 };

src/openApi/v2/parser/getServiceName.ts

@@ -1,13 +1,12 @@
 import camelCase from 'camelcase';
 
+import sanitizeServiceName from '../../../utils/sanitizeServiceName';
+
 /**
  * Convert the input value to a correct service name. This converts
  * the input string to PascalCase.
  */
 export const getServiceName = (value: string): string => {
-    const clean = value
-        .replace(/^[^a-zA-Z]+/g, '')
-        .replace(/[^\w\-]+/g, '-')
-        .trim();
+    const clean = sanitizeServiceName(value).trim();
     return camelCase(clean, { pascalCase: true });
 };

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/getOperationName.ts

@@ -1,18 +1,15 @@
 import camelCase from 'camelcase';
 
+import sanitizeOperationName from '../../../utils/sanitizeOperationName';
+
 /**
  * Convert the input value to a correct operation (method) classname.
  * This will use the operation ID - if available - and otherwise fallback
  * on a generated name from the URL
  */
 export const getOperationName = (url: string, method: string, operationId?: string): string => {
     if (operationId) {
-        return camelCase(
-            operationId
-                .replace(/^[^a-zA-Z]+/g, '')
-                .replace(/[^\w\-]+/g, '-')
-                .trim()
-        );
+        return camelCase(sanitizeOperationName(operationId).trim());
     }
 
     const urlWithoutPlaceholders = url

src/openApi/v3/parser/getOperationParameterName.ts

@@ -1,16 +1,13 @@
 import camelCase from 'camelcase';
 
 import { reservedWords } from '../../../utils/reservedWords';
+import sanitizeOperationParameterName from '../../../utils/sanitizeOperationParameterName';
 
 /**
  * Replaces any invalid characters from a parameter name.
  * For example: 'filter.someProperty' becomes 'filterSomeProperty'.
  */
 export const getOperationParameterName = (value: string): string => {
-    const clean = value
-        .replace(/^[^a-zA-Z]+/g, '')
-        .replace('[]', 'Array')
-        .replace(/[^\w\-]+/g, '-')
-        .trim();
+    const clean = sanitizeOperationParameterName(value).trim();
     return camelCase(clean).replace(reservedWords, '_$1');
 };

src/openApi/v3/parser/getServiceName.spec.ts

@@ -9,5 +9,6 @@ describe('getServiceName', () => {
         expect(getServiceName('@fooBar')).toEqual('FooBar');
         expect(getServiceName('$fooBar')).toEqual('FooBar');
         expect(getServiceName('123fooBar')).toEqual('FooBar');
+        expect(getServiceName('non-ascii-æøåÆØÅöôêÊ字符串')).toEqual('NonAsciiÆøåÆøÅöôêÊ字符串');
     });
 });

src/openApi/v3/parser/getServiceName.ts

@@ -1,13 +1,12 @@
 import camelCase from 'camelcase';
 
+import sanitizeServiceName from '../../../utils/sanitizeServiceName';
+
 /**
  * Convert the input value to a correct service name. This converts
  * the input string to PascalCase.
  */
 export const getServiceName = (value: string): string => {
-    const clean = value
-        .replace(/^[^a-zA-Z]+/g, '')
-        .replace(/[^\w\-]+/g, '-')
-        .trim();
+    const clean = sanitizeServiceName(value).trim();
     return camelCase(clean, { pascalCase: true });
 };

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/sanitizeOperationName.ts

@@ -0,0 +1,7 @@
+import sanitizeServiceName from './sanitizeServiceName';
+
+/**
+ * sanitizeOperationName does the same as sanitizeServiceName.
+ */
+const sanitizeOperationName = sanitizeServiceName;
+export default sanitizeOperationName;

src/utils/sanitizeOperationParameterName.ts

@@ -0,0 +1,7 @@
+import sanitizeOperationName from './sanitizeOperationName';
+
+const sanitizeOperationParameterName = (name: string): string => {
+    const withoutBrackets = name.replace('[]', 'Array');
+    return sanitizeOperationName(withoutBrackets);
+};
+export default sanitizeOperationParameterName;

src/utils/sanitizeServiceName.ts

@@ -0,0 +1,18 @@
+/**
+ * Sanitizes service names, 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
+ *
+ * The output of this is expected to be converted to PascalCase
+ */
+const sanitizeServiceName = (name: string) =>
+    name.replace(/^[^\p{ID_Start}]+/u, '').replace(/[^$\u200c\u200d\p{ID_Continue}]/gu, '-');
+
+export default sanitizeServiceName;

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;

src/utils/validTypescriptIdentifierRegex.ts

@@ -0,0 +1,4 @@
+// Javascript identifier regexp pattern retrieved from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers
+const validTypescriptIdentifierRegex = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
+
+export default validTypescriptIdentifierRegex;