@tabuckner/doggo-translator-ts
Version:
A typescript doggo translator based on DoggoTranslatorCore
292 lines (283 loc) • 10.7 kB
JavaScript
var LANGUAGE_TOKENS_ENUM;
(function (LANGUAGE_TOKENS_ENUM) {
LANGUAGE_TOKENS_ENUM["english"] = "en";
LANGUAGE_TOKENS_ENUM["userDefined"] = "userDefined";
})(LANGUAGE_TOKENS_ENUM || (LANGUAGE_TOKENS_ENUM = {}));
var TokensService = /** @class */ (function () {
function TokensService() {
}
TokensService.getAllLanguageTokenKeys = function () {
return Object.keys(LANGUAGE_TOKENS_ENUM);
};
TokensService.getAllLanguageTokens = function () {
return Object.values(LANGUAGE_TOKENS_ENUM);
};
TokensService.languageAvailable = function (languageToken) {
var matchesArray = this.getAllLanguageTokens().filter(function (token) { return token === languageToken; });
return matchesArray.length > 0;
};
return TokensService;
}());
var EN_TRANSLATION_SUFFIXES = {
ing: 'in'
};
var EN_TRANSLATION_WORDS = {
friend: 'fren',
small: 'smol',
dog: 'doggo',
dogs: 'doggos',
doggy: 'doggo',
doggies: 'doggos',
'smol doggo': 'pupper',
'smol doggos': 'puppers',
puppy: 'pupper',
puppies: 'puppers',
'smol pupper': 'pupperino',
'smol puppers': 'pupperinos',
'big doggo': 'woofer',
'big doggos': 'woofers',
'big ol doggo': 'woofer',
'big ol doggos': 'woofers',
'smol woofer': 'doggo',
'smol woofers': 'doggos',
corgi: 'corgo',
corgis: 'corgos',
pug: 'puggo',
pugs: 'puggos',
'smol pug': 'puggorino',
'smol pugs': 'puggorinos',
shiba: 'shibe',
shibas: 'shibes',
samoyed: 'cloud boye',
samoyeds: 'cloud boyes',
beaver: '???',
beavers: '???s',
seal: 'waterdoggo',
seals: 'waterdoggos',
bark: 'bork',
barking: 'borking',
hell: 'heck',
have: 'hav',
never: 'nvr',
good: 'gud',
when: 'wen',
hike: 'hik',
name: 'naym',
with: 'wit',
love: 'luv',
touch: 'boop',
touching: 'booping',
face: 'snoot',
human: 'hooman',
boy: 'boye',
boys: 'boyes',
lick: 'mlem',
licked: 'mlemmed',
licks: 'mlems',
licking: 'mlemming',
his: 'hims',
'you are scaring me': 'you are doing me a scare',
'you are frightening me': 'you are doing me a frighten',
'you are startling me': 'you are doing me a startle'
};
var EN_TRANSLATIONS = {
words: EN_TRANSLATION_WORDS,
suffixes: EN_TRANSLATION_SUFFIXES
};
var ErrorService = /** @class */ (function () {
function ErrorService() {
}
/**
* Logs an error message to the console with a prefix.
* @param message Message to log
*/
ErrorService.logError = function (message) {
var error = ErrorService.buildError(message);
console.error(error); //tslint:disable-line
};
ErrorService.throw = function (message) {
var error = ErrorService.buildError(message);
throw error;
};
ErrorService.buildError = function (message) {
return new Error("[DoggoTranslatorTS] " + message);
};
return ErrorService;
}());
var LocaleLoaderService = /** @class */ (function () {
function LocaleLoaderService() {
}
LocaleLoaderService.prototype.setTranslationsMap = function (newTranslationsMap) {
this.translationsMap = newTranslationsMap;
};
LocaleLoaderService.prototype.loadLibraryTranslations = function (token) {
switch (token) {
case LANGUAGE_TOKENS_ENUM.english:
return this.setTranslationsMap(EN_TRANSLATIONS);
default:
return this.setTranslationsMap(EN_TRANSLATIONS);
}
};
LocaleLoaderService.prototype.getTranslationsMap = function () {
if (!this.translationMapHasTranslations) {
ErrorService.logError('No translations found in TranslationsMap.');
}
return this.translationsMap;
};
Object.defineProperty(LocaleLoaderService.prototype, "translationMapHasTranslations", {
get: function () {
return !!(Object.keys(this.translationsMap).length > 0);
},
enumerable: true,
configurable: true
});
return LocaleLoaderService;
}());
// Import here Polyfills if needed. Recommended core-js (npm i -D core-js)
// import "core-js/fn/array.find"
/**
* Given a language.json object, returns an instance of `DoggoTranslator`.
*/
var DoggoTranslator = /** @class */ (function () {
function DoggoTranslator(config) {
this.defaultResponse = 'Bork';
this.defaultLanguage = LANGUAGE_TOKENS_ENUM.english;
this.localeLoaderService = new LocaleLoaderService();
this.configValidation(config);
this.setUpTranslator(config);
}
/**
*
* @param sourceSentence Sentence in the sourceLanguage
* @param reverse boolean to control direction of translation (e.g. true = sourceLanguage => doggo, false = doggo => sourceLanguage)
*/
DoggoTranslator.prototype.translateSentence = function (sourceSentence, reverse) {
if (reverse === void 0) { reverse = false; }
if (sourceSentence === '') {
return this.defaultResponse;
}
var translationsMap = this.localeLoaderService.getTranslationsMap();
var words = translationsMap.words;
var suffixes = translationsMap.suffixes;
sourceSentence = this.replaceWholeWords(words, reverse, sourceSentence);
if (suffixes) {
sourceSentence = this.replaceSuffixes(suffixes, reverse, sourceSentence);
}
return sourceSentence;
};
/**
* Returns available languages.
*/
DoggoTranslator.prototype.getAllLanguageTokens = function () {
return TokensService.getAllLanguageTokens();
};
/**
* Given a language token, will attempt to set the current language.
* @param languageToken the language token
*/
DoggoTranslator.prototype.setLanguage = function (languageToken) {
if (!this.languageAvailable(languageToken)) {
ErrorService.logError("The language was not found, defaulting to " + this.defaultLanguage);
this.languageToken = this.defaultLanguage;
return this.localeLoaderService.loadLibraryTranslations(languageToken);
}
this.languageToken = languageToken;
return this.localeLoaderService.loadLibraryTranslations(languageToken);
};
DoggoTranslator.prototype.configValidation = function (config) {
if (!config || (!config.languageToken && !config.userTranslationsMap)) {
ErrorService.throw('Invalid Config Provided. You must provide at least one of the following: \n\t`languageToken` or `userTranslationsMap`');
}
};
DoggoTranslator.prototype.setUpTranslator = function (config) {
if (!config.userTranslationsMap) {
return this.setLanguage(config.languageToken);
}
this.setLanguage(LANGUAGE_TOKENS_ENUM.userDefined);
return this.localeLoaderService.setTranslationsMap(config.userTranslationsMap);
};
/**
* Given a language token, will return whether the language is available.
* @param language language token
*/
DoggoTranslator.prototype.languageAvailable = function (languageToken) {
return TokensService.languageAvailable(languageToken);
};
DoggoTranslator.prototype.replaceWholeWords = function (words, reverse, sourceSentence) {
for (var key in words) {
if (words.hasOwnProperty(key)) {
var value = words[key];
if (!reverse) {
sourceSentence = this.translateWholeWord(sourceSentence, key, value);
}
else {
sourceSentence = this.translateWholeWord(sourceSentence, value, key);
}
}
}
return sourceSentence;
};
DoggoTranslator.prototype.replaceSuffixes = function (suffixes, reverse, sourceSentence) {
for (var key in suffixes) {
if (suffixes.hasOwnProperty(key)) {
var value = suffixes[key];
if (!reverse) {
sourceSentence = this.transformSuffixes(sourceSentence, key, value);
}
else {
sourceSentence = this.transformSuffixes(sourceSentence, value, key);
}
}
}
return sourceSentence;
};
/**
* Replaces a part from the input and tries to format it with the proper case.
* @param input The complete input
* @param find The word or sentence to find
* @param replace The word or sentence to replace the found word or sentence
*/
DoggoTranslator.prototype.translateWholeWord = function (input, regex, replace) {
var _this = this;
regex = this.escapeRegex(regex);
return input.replace(new RegExp('\\b(' + regex + ')\\b', 'gi'), function (match) {
if (match === match.toUpperCase()) {
return replace.toUpperCase();
}
if (match === _this.capitalizeFirstCharacter(match)) {
return _this.capitalizeFirstCharacter(replace);
}
return replace;
});
};
DoggoTranslator.prototype.transformSuffixes = function (input, regex, replace) {
regex = this.escapeRegex(regex);
return input.replace(new RegExp('(' + regex + ')\\b', 'gi'), function (match) {
if (match === match.toUpperCase()) {
return replace.toUpperCase();
}
// TODO: Add support for respecting character capitalization.
return replace;
});
};
/**
* Returns a string with the first character capitalized.
* @param target The string to format
*/
DoggoTranslator.prototype.capitalizeFirstCharacter = function (target) {
var firstCharacterCapitalized = target.charAt(0).toUpperCase();
var restOfTheWord = target.slice(1);
return "" + firstCharacterCapitalized + restOfTheWord;
};
/**
* Given a string, returns the string with all special characters escaped so that the translation
* regex see them as special characters.
* @param target The string to escape
*/
DoggoTranslator.prototype.escapeRegex = function (target) {
return target.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
};
return DoggoTranslator;
}());
export { DoggoTranslator, LANGUAGE_TOKENS_ENUM };
//# sourceMappingURL=doggo-translator-ts.es5.js.map