node-server-engine 1.1.4 → 1.1.5

package/src/entities/Localizator/guessNamingConvention/guessNamingConvention.test.ts

@@ -1,165 +1,165 @@
-import { expect } from 'chai';
-import { faker } from '@faker-js/faker';
-import {
-  LocalizatorScript,
-  LocalizatorLocalizationDataElement
-} from '../Localizator.types';
-import {
-  guessNamingConvention,
-  DEFAULT_NAMING_CONVENTION
-} from './guessNamingConvention';
-
-/** Generate fake script config */
-function generateScriptData(
-  overrides: Partial<LocalizatorScript> = {}
-): LocalizatorScript {
-  return {
-    rangeRegex: new RegExp(`^\b$`, 'u'),
-    ranges: ['a'],
-    names: {
-      casual: faker.lorem.slug(),
-      regular: faker.lorem.slug(),
-      formal: faker.lorem.slug()
-    },
-    ...overrides
-  };
-}
-
-/** Generate locales file random data */
-function generateLocalizationData(
-  overrides: Partial<LocalizatorLocalizationDataElement> = {}
-): LocalizatorLocalizationDataElement {
-  return {
-    script: faker.lorem.word(),
-    enabled: true,
-    display: faker.lorem.word(),
-    names: {
-      firstNameFirst: true,
-      spacing: true
-    },
-    cloudTranslationKey: faker.location.countryCode(),
-    ...overrides
-  };
-}
-
-describe('Service - Localizator - Guess naming convention', function () {
-  it('should return the convention for the locale specifc script', function () {
-    const locale = faker.location.country();
-    const userScript = faker.lorem.word();
-    const name = faker.lorem.word();
-    const scriptData = generateScriptData({
-      rangeRegex: new RegExp(name, 'u')
-    });
-
-    const Localizator = {
-      localeData: {
-        [faker.location.countryCode()]: generateLocalizationData(),
-        [locale]: generateLocalizationData({ script: userScript })
-      },
-      scripts: {
-        [faker.lorem.word()]: generateScriptData(),
-        [userScript]: scriptData
-      }
-    };
-    const result = guessNamingConvention(
-      Localizator.scripts,
-      Localizator.localeData,
-      name,
-      locale
-    );
-
-    expect(result).to.equal(scriptData.names);
-  });
-
-  it('should return the convention for the the script detected in the name if no match wirth the default script', function () {
-    const locale = faker.location.country();
-    const expectedResult = {
-      casual: faker.lorem.word(),
-      regular: faker.lorem.word(),
-      formal: faker.lorem.word()
-    };
-    const userScript = faker.lorem.word();
-    const name = faker.lorem.word();
-    const Localizator = {
-      localeData: {
-        [faker.location.countryCode()]: generateLocalizationData(),
-        [locale]: generateLocalizationData({ script: userScript })
-      },
-      scripts: {
-        [faker.lorem.word()]: generateScriptData(),
-        [userScript]: generateScriptData(),
-        [faker.lorem.word()]: generateScriptData({
-          rangeRegex: new RegExp(name, 'u'),
-          names: expectedResult
-        })
-      }
-    };
-    const result = guessNamingConvention(
-      Localizator.scripts,
-      Localizator.localeData,
-      name,
-      locale
-    );
-    expect(result).to.equal(expectedResult);
-  });
-
-  it('should return the convention for the locale if no script match', function () {
-    const locale = faker.location.country();
-    const expectedResult = {
-      casual: faker.lorem.word(),
-      regular: faker.lorem.word(),
-      formal: faker.lorem.word()
-    };
-    const userScript = faker.lorem.word();
-    const name = faker.lorem.word();
-    const Localizator = {
-      localeData: {
-        [faker.location.countryCode()]: generateLocalizationData({
-          script: faker.lorem.word()
-        }),
-        [locale]: generateLocalizationData({
-          script: userScript,
-          names: {
-            firstNameFirst: true,
-            spacing: true,
-            fallback: expectedResult
-          }
-        })
-      },
-      scripts: {
-        [faker.lorem.word()]: generateScriptData(),
-        [userScript]: generateScriptData()
-      }
-    };
-    const result = guessNamingConvention(
-      Localizator.scripts,
-      Localizator.localeData,
-      name,
-      locale
-    );
-    expect(result).to.equal(expectedResult);
-  });
-
-  it('should use the default if no fallback exist', function () {
-    const locale = faker.location.country();
-    const userScript = faker.lorem.word();
-    const name = faker.lorem.word();
-    const Localizator = {
-      localeData: {
-        [faker.location.countryCode()]: generateLocalizationData(),
-        [locale]: generateLocalizationData({ script: userScript })
-      },
-      scripts: {
-        [faker.lorem.word()]: generateScriptData(),
-        [userScript]: generateScriptData()
-      }
-    };
-    const result = guessNamingConvention(
-      Localizator.scripts,
-      Localizator.localeData,
-      name,
-      locale
-    );
-    expect(result).to.equal(DEFAULT_NAMING_CONVENTION);
-  });
-});
+import { expect } from 'chai';
+import { faker } from '@faker-js/faker';
+import {
+  LocalizatorScript,
+  LocalizatorLocalizationDataElement
+} from '../Localizator.types';
+import {
+  guessNamingConvention,
+  DEFAULT_NAMING_CONVENTION
+} from './guessNamingConvention';
+
+/** Generate fake script config */
+function generateScriptData(
+  overrides: Partial<LocalizatorScript> = {}
+): LocalizatorScript {
+  return {
+    rangeRegex: new RegExp(`^\b$`, 'u'),
+    ranges: ['a'],
+    names: {
+      casual: faker.lorem.slug(),
+      regular: faker.lorem.slug(),
+      formal: faker.lorem.slug()
+    },
+    ...overrides
+  };
+}
+
+/** Generate locales file random data */
+function generateLocalizationData(
+  overrides: Partial<LocalizatorLocalizationDataElement> = {}
+): LocalizatorLocalizationDataElement {
+  return {
+    script: faker.lorem.word(),
+    enabled: true,
+    display: faker.lorem.word(),
+    names: {
+      firstNameFirst: true,
+      spacing: true
+    },
+    cloudTranslationKey: faker.location.countryCode(),
+    ...overrides
+  };
+}
+
+describe('Service - Localizator - Guess naming convention', function () {
+  it('should return the convention for the locale specifc script', function () {
+    const locale = faker.location.country();
+    const userScript = faker.lorem.word();
+    const name = faker.lorem.word();
+    const scriptData = generateScriptData({
+      rangeRegex: new RegExp(name, 'u')
+    });
+
+    const Localizator = {
+      localeData: {
+        [faker.location.countryCode()]: generateLocalizationData(),
+        [locale]: generateLocalizationData({ script: userScript })
+      },
+      scripts: {
+        [faker.lorem.word()]: generateScriptData(),
+        [userScript]: scriptData
+      }
+    };
+    const result = guessNamingConvention(
+      Localizator.scripts,
+      Localizator.localeData,
+      name,
+      locale
+    );
+
+    expect(result).to.equal(scriptData.names);
+  });
+
+  it('should return the convention for the the script detected in the name if no match wirth the default script', function () {
+    const locale = faker.location.country();
+    const expectedResult = {
+      casual: faker.lorem.word(),
+      regular: faker.lorem.word(),
+      formal: faker.lorem.word()
+    };
+    const userScript = faker.lorem.word();
+    const name = faker.lorem.word();
+    const Localizator = {
+      localeData: {
+        [faker.location.countryCode()]: generateLocalizationData(),
+        [locale]: generateLocalizationData({ script: userScript })
+      },
+      scripts: {
+        [faker.lorem.word()]: generateScriptData(),
+        [userScript]: generateScriptData(),
+        [faker.lorem.word()]: generateScriptData({
+          rangeRegex: new RegExp(name, 'u'),
+          names: expectedResult
+        })
+      }
+    };
+    const result = guessNamingConvention(
+      Localizator.scripts,
+      Localizator.localeData,
+      name,
+      locale
+    );
+    expect(result).to.equal(expectedResult);
+  });
+
+  it('should return the convention for the locale if no script match', function () {
+    const locale = faker.location.country();
+    const expectedResult = {
+      casual: faker.lorem.word(),
+      regular: faker.lorem.word(),
+      formal: faker.lorem.word()
+    };
+    const userScript = faker.lorem.word();
+    const name = faker.lorem.word();
+    const Localizator = {
+      localeData: {
+        [faker.location.countryCode()]: generateLocalizationData({
+          script: faker.lorem.word()
+        }),
+        [locale]: generateLocalizationData({
+          script: userScript,
+          names: {
+            firstNameFirst: true,
+            spacing: true,
+            fallback: expectedResult
+          }
+        })
+      },
+      scripts: {
+        [faker.lorem.word()]: generateScriptData(),
+        [userScript]: generateScriptData()
+      }
+    };
+    const result = guessNamingConvention(
+      Localizator.scripts,
+      Localizator.localeData,
+      name,
+      locale
+    );
+    expect(result).to.equal(expectedResult);
+  });
+
+  it('should use the default if no fallback exist', function () {
+    const locale = faker.location.country();
+    const userScript = faker.lorem.word();
+    const name = faker.lorem.word();
+    const Localizator = {
+      localeData: {
+        [faker.location.countryCode()]: generateLocalizationData(),
+        [locale]: generateLocalizationData({ script: userScript })
+      },
+      scripts: {
+        [faker.lorem.word()]: generateScriptData(),
+        [userScript]: generateScriptData()
+      }
+    };
+    const result = guessNamingConvention(
+      Localizator.scripts,
+      Localizator.localeData,
+      name,
+      locale
+    );
+    expect(result).to.equal(DEFAULT_NAMING_CONVENTION);
+  });
+});

package/src/entities/Localizator/guessNamingConvention/guessNamingConvention.ts

@@ -1,58 +1,58 @@
-import {
-  LocalizatorLocalizationData,
-  LocalizatorScripts,
-  LocalizatorNamingConventions
-} from '../Localizator.types';
-
-export const DEFAULT_NAMING_CONVENTION = {
-  regular: '{firstName} {lastName}',
-  formal: '{firstName}',
-  casual: '{firstName}'
-};
-
-/** Guess the naming convention to use for a given name and locale */
-export function guessNamingConvention(
-  scripts: LocalizatorScripts,
-  localeData: LocalizatorLocalizationData,
-  name: string,
-  locale: string
-): LocalizatorNamingConventions {
-  // When the locale has a specific script
-  // Check if the name matches that script, and use its naming convention
-  if (localeData[locale]?.script) {
-    const defaultScript = localeData[locale].script as string;
-    if (
-      testScriptMatch(scripts, defaultScript, name) &&
-      scripts[defaultScript].names
-    ) {
-      return scripts[defaultScript].names;
-    }
-  }
-
-  // Check if there is a match with any given script and use its naming convention
-  for (const script of Object.keys(scripts)) {
-    if (testScriptMatch(scripts, script, name) && scripts[script].names) {
-      return scripts[script].names;
-    }
-  }
-
-  // Use the current locale's fallback convention
-  if (localeData[locale]?.names?.fallback) {
-    return localeData[locale].names.fallback as LocalizatorNamingConventions;
-  }
-
-  // If everything fails, use the default convention
-  return DEFAULT_NAMING_CONVENTION;
-}
-
-/** Test if a given string is in a given script */
-function testScriptMatch(
-  scripts: LocalizatorScripts,
-  script: string,
-  string: string
-): boolean {
-  if (scripts[script]?.rangeRegex) {
-    return (scripts[script].rangeRegex as RegExp).test(string);
-  }
-  return false;
-}
+import {
+  LocalizatorLocalizationData,
+  LocalizatorScripts,
+  LocalizatorNamingConventions
+} from '../Localizator.types';
+
+export const DEFAULT_NAMING_CONVENTION = {
+  regular: '{firstName} {lastName}',
+  formal: '{firstName}',
+  casual: '{firstName}'
+};
+
+/** Guess the naming convention to use for a given name and locale */
+export function guessNamingConvention(
+  scripts: LocalizatorScripts,
+  localeData: LocalizatorLocalizationData,
+  name: string,
+  locale: string
+): LocalizatorNamingConventions {
+  // When the locale has a specific script
+  // Check if the name matches that script, and use its naming convention
+  if (localeData[locale]?.script) {
+    const defaultScript = localeData[locale].script as string;
+    if (
+      testScriptMatch(scripts, defaultScript, name) &&
+      scripts[defaultScript].names
+    ) {
+      return scripts[defaultScript].names;
+    }
+  }
+
+  // Check if there is a match with any given script and use its naming convention
+  for (const script of Object.keys(scripts)) {
+    if (testScriptMatch(scripts, script, name) && scripts[script].names) {
+      return scripts[script].names;
+    }
+  }
+
+  // Use the current locale's fallback convention
+  if (localeData[locale]?.names?.fallback) {
+    return localeData[locale].names.fallback as LocalizatorNamingConventions;
+  }
+
+  // If everything fails, use the default convention
+  return DEFAULT_NAMING_CONVENTION;
+}
+
+/** Test if a given string is in a given script */
+function testScriptMatch(
+  scripts: LocalizatorScripts,
+  script: string,
+  string: string
+): boolean {
+  if (scripts[script]?.rangeRegex) {
+    return (scripts[script].rangeRegex as RegExp).test(string);
+  }
+  return false;
+}

package/src/entities/Localizator/guessNamingConvention/index.ts

@@ -1 +1 @@
-export * from './guessNamingConvention';
+export * from './guessNamingConvention';

package/src/entities/Localizator/index.ts

@@ -1,2 +1,2 @@
-export * from './Localizator';
-export * from './Localizator.types';
+export * from './Localizator';
+export * from './Localizator.types';