@stevenkellner/team-conduct-api 1.0.22 → 1.0.24

package/src/locales/de.ts

@@ -0,0 +1,97 @@
+import { Pluralization } from '../types/Pluralization';
+
+export const localizationDE = {
+    notification: {
+        fine: {
+            new: {
+                title: '{{reason}}',
+                body: 'Du hast eine neue Strafe von {{amount}}. Bitte so schnell wie möglich zahlen.'
+            },
+            reminder: {
+                title: 'Du hast noch offene Strafen',
+                body: 'Bei dir sind noch {{amount}} offen. Bitte so schnell wie möglich zahlen.'
+            },
+            stateChange: {
+                title: 'Eine deiner Strafen hat sich geändert',
+                bodyPayed: 'Du hast eine Strafe von {{amount}} bezahlt ({{reason}}).',
+                bodyUnpayed: '{{reason}}, {{amount}} ist noch offen.',
+                bodyDeleted: '{{reason}}, {{amount}} wurde gelöscht.'
+            }
+        }
+    },
+    fineAmount: {
+        item: {
+            type: {
+                crateOfBeer: {
+                    name: 'Kasten Bier',
+                    withCount: new Pluralization({
+                        one: 'Ein Kasten Bier',
+                        other: '{{count}} Kästen Bier'
+                    }),
+                    withoutCount: new Pluralization({
+                        one: 'Kasten Bier',
+                        other: 'Kästen Bier'
+                    })
+                }
+            }
+        }
+    },
+    fineTemplateRepetition: {
+        item: {
+            minute: {
+                name: 'Minute',
+                withCount: new Pluralization({
+                    one: '1 Minute',
+                    other: '{{count}} Minuten'
+                }),
+                withoutCount: new Pluralization({
+                    one: 'Minute',
+                    other: 'Minuten'
+                })
+            },
+            day: {
+                name: 'Tag',
+                withCount: new Pluralization({
+                    one: '1 Tag',
+                    other: '{{count}} Tage'
+                }),
+                withoutCount: new Pluralization({
+                    one: 'Tag',
+                    other: 'Tage'
+                })
+            },
+            item: {
+                name: 'Teil',
+                withCount: new Pluralization({
+                    one: '1 Teil',
+                    other: '{{count}} Teile'
+                }),
+                withoutCount: new Pluralization({
+                    one: 'Teil',
+                    other: 'Teile'
+                })
+            },
+            count: {
+                name: 'Anzahl',
+                withCount: new Pluralization({
+                    one: '1 mal',
+                    other: '{{count}} mal'
+                }),
+                withoutCount: new Pluralization({
+                    one: 'mal',
+                    other: 'mal'
+                })
+            }
+        }
+    },
+    payedState: {
+        payed: 'Bezahlt',
+        notPayed: 'Offen'
+    },
+    userRole: {
+        personManager: 'Personenmanager',
+        fineTemplateManager: 'Strafvorlagenmanager',
+        fineManager: 'Strafenmanager',
+        teamManager: 'Teammanager'
+    }
+}

package/src/locales/en.ts

@@ -0,0 +1,97 @@
+import { Pluralization } from '../types/Pluralization';
+
+export const localizationEN = {
+    notification: {
+        fine: {
+            new: {
+                title: '{{reason}}',
+                body: 'You have a new fine of {{amount}}. Please pay it as soon as possible.'
+            },
+            reminder: {
+                title: 'You still have outstanding fines',
+                body: 'You still have {{amount}} outstanding. Please pay as soon as possible.'
+            },
+            stateChange: {
+                title: 'One of your fines has changed',
+                bodyPayed: 'You have paid a fine of {{amount}} ({{reason}}).',
+                bodyUnpayed: '{{reason}}, {{amount}} is still outstanding.',
+                bodyDeleted: '{{reason}}, {{amount}} has been deleted.'
+            }
+        }
+    },
+    fineAmount: {
+        item: {
+            type: {
+                crateOfBeer: {
+                    name: 'Crate of Beer',
+                    withCount: new Pluralization({
+                        one: 'a crate of beer',
+                        other: '{{count}} crates of beer'
+                    }),
+                    withoutCount: new Pluralization({
+                        one: 'Crate of Beer',
+                        other: 'Crates of Beer'
+                    })
+                }
+            }
+        }
+    },
+    fineTemplateRepetition: {
+        item: {
+            minute: {
+                name: 'Minute',
+                withCount: new Pluralization({
+                    one: '1 minute',
+                    other: '{{count}} minutes'
+                }),
+                withoutCount: new Pluralization({
+                    one: 'minute',
+                    other: 'minutes'
+                })
+            },
+            day: {
+                name: 'Day',
+                withCount: new Pluralization({
+                    one: '1 day',
+                    other: '{{count}} days'
+                }),
+                withoutCount: new Pluralization({
+                    one: 'day',
+                    other: 'days'
+                })
+            },
+            item: {
+                name: 'Item',
+                withCount: new Pluralization({
+                    one: '1 item',
+                    other: '{{count}} items'
+                }),
+                withoutCount: new Pluralization({
+                    one: 'item',
+                    other: 'items'
+                })
+            },
+            count: {
+                name: 'Count',
+                withCount: new Pluralization({
+                    one: '1 time',
+                    other: '{{count}} times'
+                }),
+                withoutCount: new Pluralization({
+                    one: 'time',
+                    other: 'times'
+                })
+            }
+        }
+    },
+    payedState: {
+        payed: 'Paid',
+        notPayed: 'Outstanding'
+    },
+    userRole: {
+        personManager: 'Person Manager',
+        fineTemplateManager: 'Fine Template Manager',
+        fineManager: 'Fine Manager',
+        teamManager: 'Team Manager'
+    }
+}

package/src/types/Configuration.ts

@@ -1,4 +1,5 @@
-import { Flattable, ITypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { localizations } from './Localization';
+import { Flattable, ITypeBuilder, keys, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
 export class Configuration implements Flattable<Configuration.Flatten> {
 
@@ -26,11 +27,11 @@ export namespace Configuration {
         export const builder = new ValueTypeBuilder<Currency>();
     }
 
-    export type Locale = 'de' | 'en';
+    export type Locale = keyof typeof localizations;
 
     export namespace Locale {
 
-        export const all: Locale[] = ['de', 'en'];
+        export const all: Locale[] = keys(localizations);
 
         export const builder = new ValueTypeBuilder<Locale>();
     }

package/src/types/FineAmount.ts

@@ -56,11 +56,11 @@ export namespace FineAmount {
         ) {}
 
         public formatted(): string {
-            return Localization.shared.getN(key => key.fineAmount.item.type[this.item], this.count);
+            return Localization.shared.fineAmount.item.type[this.item].withCount.value(this.count);
         }
 
         public formattedWithoutCount(): string {
-            return Localization.shared.getN(key => key.fineAmount.item.type[`${this.item}WithoutCount`], this.count);
+            return Localization.shared.fineAmount.item.type[this.item].withoutCount.value(this.count);
         }
 
         public multiplied(factor: number): Item {
@@ -86,7 +86,7 @@ export namespace FineAmount {
             export const all: Type[] = ['crateOfBeer'];
 
             export function formatted(type: Type): string {
-                return Localization.shared.get(key => key.fineAmount.item.type[type]);
+                return Localization.shared.fineAmount.item.type[type].name.value();
             }
         }
 

package/src/types/FineTemplateRepetition.ts

@@ -9,11 +9,11 @@ export class FineTemplateRepetition implements Flattable<FineTemplateRepetition.
     ) {}
 
     public formatted(count: number): string {
-        return Localization.shared.getN(key => key.fineTemplateRepetition.item[this.item], count);
+        return Localization.shared.fineTemplateRepetition.item[this.item].withCount.value(count);
     }
 
     public formattedWithoutCount(count: number): string {
-        return Localization.shared.getN(key => key.fineTemplateRepetition.item[`${this.item}WithoutCount`], count);
+        return Localization.shared.fineTemplateRepetition.item[this.item].withoutCount.value(count);
     }
 
     public get flatten(): FineTemplateRepetition.Flatten {
@@ -42,7 +42,7 @@ export namespace FineTemplateRepetition {
         ];
 
         export function formatted(item: Item): string {
-            return Localization.shared.get(key => key.fineTemplateRepetition.item[item]);
+            return Localization.shared.fineTemplateRepetition.item[item].name.value();
         }
 
         export const builder = new ValueTypeBuilder<Item>();

package/src/types/Localization.ts

@@ -1,99 +1,83 @@
-import * as i18n from 'i18n';
-import { Configuration } from './Configuration';
+import { keys, mapRecord, values } from '@stevenkellner/typescript-common-functionality';
+import { localizationEN } from '../locales/en';
+import { localizationDE } from '../locales/de';
+import { Pluralization } from './Pluralization';
 
-export const localizationKey = {
-    notification: {
-        fine: {
-            new: {
-                title: 'notification.fine.new.title',
-                body: 'notification.fine.new.body'
-            },
-            reminder: {
-                title: 'notification.fine.reminder.title',
-                body: 'notification.fine.reminder.body'
-            },
-            stateChange: {
-                title: 'notification.fine.state-change.title',
-                bodyPayed: 'notification.fine.state-change.body-payed',
-                bodyUnpayed: 'notification.fine.state-change.body-unpayed',
-                bodyDeleted: 'notification.fine.state-change.body-deleted'
-            }
-        }
-    },
-    fineAmount: {
-        item: {
-            type: {
-                crateOfBeer: 'fineAmount.item.type.crateOfBeer'
-            }
-        }
-    },
-    fineTemplateRepetition: {
-        item: {
-            minute: 'fineTemplateRepetition.item.minute',
-            day: 'fineTemplateRepetition.item.day',
-            item: 'fineTemplateRepetition.item.item',
-            count: 'fineTemplateRepetition.item.count'
-        }
-    },
-    payedState: {
-        payed: 'payedState.payed',
-        notPayed: 'payedState.notPayed'
-    },
-    userRole: {
-        personManager: 'userRole.personManager',
-        fineTemplateManager: 'userRole.fineTemplateManager',
-        fineManager: 'userRole.fineManager',
-        teamManager: 'userRole.teamManager'
-    }
-}
+export const localizations = {
+    en: localizationEN,
+    de: localizationDE
+};
 
-export const localizationNKey = {
-    fineAmount: {
-        item: {
-            type: {
-                crateOfBeer: 'fineAmount.item.type.crateOfBeer?count=%s',
-                crateOfBeerWithoutCount: 'fineAmount.item.type.crateOfBeerWithoutCount?count=%s'
-            }
-        }
-    },
-    fineTemplateRepetition: {
-        item: {
-            minute: 'fineTemplateRepetition.item.minute?count=%s',
-            minuteWithoutCount: 'fineTemplateRepetition.item.minuteWithoutCount?count=%s',
-            day: 'fineTemplateRepetition.item.day?count=%s',
-            dayWithoutCount: 'fineTemplateRepetition.item.dayWithoutCount?count=%s',
-            item: 'fineTemplateRepetition.item.item?count=%s',
-            itemWithoutCount: 'fineTemplateRepetition.item.itemWithoutCount?count=%s',
-            count: 'fineTemplateRepetition.item.count?count=%s',
-            countWithoutCount: 'fineTemplateRepetition.item.countWithoutCount?count=%s'
+export type SubLocalizationType = { [Key in string]: SubLocalizationType } | string | Pluralization;
+
+export type SubLocalization<T extends SubLocalizationType> =
+    T extends { [Key in string]: SubLocalizationType } ? { [Key in keyof T]: SubLocalization<T[Key]> } :
+        T extends string ? ValueLocalization :
+        T extends Pluralization ? PluralLocalization : never;
+
+export class ValueLocalization {
+
+    constructor(private readonly rawValues: Record<keyof typeof localizations, string>) {}
+
+    public value(args: Record<string, string> = {}): string {
+        let rawValue = this.rawValues[Localization.locale];
+        const regex = /\{\{(?<key>.*?)\}\}/;
+        while (true) {
+            const match = regex.exec(rawValue);
+            if (!match)
+                break;
+            const key = match.groups!.key;
+            if (!(key in args))
+                throw new Error(`Missing argument for key: ${key}`);
+            rawValue = rawValue.replace(match[0], args[key]);
         }
+        return rawValue;
     }
 }
 
-export class Localization {
+export class PluralLocalization {
 
-    public static readonly shared = new Localization();
+    constructor(private readonly pluralizations: Record<keyof typeof localizations, Pluralization>) {}
 
-    private constructor() {
-        i18n.configure({
-            locales: Configuration.Locale.all,
-            defaultLocale: 'en',
-            directory: 'src/locales',
-            objectNotation: true
+    public value(count: number, args: Record<string, string> = {}): string {
+        const valueLocalization = new ValueLocalization(mapRecord(this.pluralizations, pluralization => pluralization.get(count)));
+        return valueLocalization.value({
+            count: `${count}`,
+            ...args
         });
     }
+}
 
-    public setLocale(locale: Configuration.Locale) {
-        i18n.setLocale(locale);
+function swap1stAnd2ndLevel<Level1Key extends string, Level2Key extends string, T>(record: Record<Level1Key, Record<Level2Key, T>>): Record<Level2Key, Record<Level1Key, T>> {
+    const swapped = {} as Record<Level2Key, Record<Level1Key, T>>;
+    for (const key1 of keys(record)) {
+        for (const key2 of keys(record[key1]) as Level2Key[]) {
+            if (!(key2 in swapped))
+                swapped[key2] = {} as Record<Level1Key, T>;
+            swapped[key2][key1] = record[key1][key2];
+        }
     }
+    return swapped;
+}
 
-    public get(getKey: (key: typeof localizationKey) => string, ...args: string[]): string {
-        const key = getKey(localizationKey);
-        return i18n.__(key, ...args);
-    }
+export class Localization {
+
+    public static locale: keyof typeof localizations = 'en';
 
-    public getN(getKey: (key: typeof localizationNKey) => string, count: number): string {
-        const key = getKey(localizationNKey);
-        return i18n.__n(key, count);
+    public static readonly shared = Localization.getSubLocalization(localizations);
+
+    private static getSubLocalization<T extends SubLocalizationType>(_localizations: Record<keyof typeof localizations, T>): SubLocalization<T> {
+        const _localizationValue = values(_localizations);
+        if (_localizationValue.length === 0)
+            return {} as SubLocalization<T>;
+        if (typeof _localizationValue[0] === 'object' && !(_localizationValue[0] instanceof Pluralization)) {
+            const swapped = swap1stAnd2ndLevel(_localizations as Record<string, Record<string, SubLocalizationType>>);
+            return mapRecord(swapped, subLocalization => Localization.getSubLocalization(subLocalization)) as SubLocalization<T>;
+        }
+        if (typeof _localizationValue[0] === 'string')
+            return new ValueLocalization(_localizations as Record<keyof typeof localizations, string>) as SubLocalization<T>;
+        if (_localizationValue[0] instanceof Pluralization)
+            return new PluralLocalization(_localizations as Record<keyof typeof localizations, Pluralization>) as SubLocalization<T>;
+        throw new Error('Invalid localization structure');
     }
 }

package/src/types/PayedState.ts

@@ -10,7 +10,7 @@ export namespace PayedState {
     export const all: PayedState[] = ['payed', 'notPayed'];
 
     export function formatted(state: PayedState): string {
-        return Localization.shared.get(key => key.payedState[state]);
+        return Localization.shared.payedState[state].value();
     }
 
     export function toggled(state: PayedState): PayedState {

package/src/types/Pluralization.ts

@@ -0,0 +1,44 @@
+export class Pluralization {
+
+    private readonly zero: string | null;
+
+    private readonly one: string | null;
+
+    private readonly two: string | null;
+
+    private readonly few: string | null;
+
+    private readonly many: string | null;
+
+    private readonly other: string;
+
+    public constructor(countLocals: {
+        zero?: string,
+        one?: string,
+        two?: string,
+        few?: string,
+        many?: string,
+        other: string
+    }) {
+        this.zero = countLocals.zero ?? null;
+        this.one = countLocals.one ?? null;
+        this.two = countLocals.two ?? null;
+        this.few = countLocals.few ?? null;
+        this.many = countLocals.many ?? null;
+        this.other = countLocals.other;
+    }
+
+    public get(count: number): string {
+        if (count === 0 && this.zero)
+            return this.zero;
+        else if (count === 1 && this.one)
+            return this.one;
+        else if (count === 2 && this.two)
+            return this.two;
+        else if (count > 1 && count < 5 && this.few)
+            return this.few;
+        else if (count >= 5 && count <= 20 && this.many)
+            return this.many;
+        return this.other;
+    }
+}

package/src/types/UserRole.ts

@@ -1,5 +1,5 @@
 import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-import { Localization, localizationKey } from './Localization';
+import { Localization, localizations } from './Localization';
 
 export type UserRole =
     | 'person-manager'
@@ -17,13 +17,13 @@ export namespace UserRole {
     ];
 
     export function formatted(role: UserRole): string {
-        const localizationKeyMap: Record<UserRole, keyof typeof localizationKey.userRole> = {
+        const localizationKeyMap: Record<UserRole, keyof (typeof localizations)[keyof typeof localizations]['userRole']> = {
             'person-manager': 'personManager',
             'fineTemplate-manager': 'fineTemplateManager',
             'fine-manager': 'fineManager',
             'team-manager': 'teamManager'
         }
-        return Localization.shared.get(key => key.userRole[localizationKeyMap[role]]);
+        return Localization.shared.userRole[localizationKeyMap[role]].value();
     }
 
     export const builder = new ValueTypeBuilder<UserRole>();

package/src/types/index.ts

@@ -11,6 +11,7 @@ export * from './PayedState';
 export * from './Person';
 export * from './PersonPrivateProperties';
 export * from './PersonSignInProperties';
+export * from './Pluralization';
 export * from './Team';
 export * from './User';
 export * from './UserRole';

package/lib/src/locales/de.json

@@ -1,85 +0,0 @@
-{
-    "notification": {
-        "fine": {
-            "new": {
-                "title": "%s",
-                "body": "Du hast eine neue Strafe von %s. Bitte so schnell wie möglich zahlen."
-            },
-            "reminder": {
-                "title": "Du hast noch offene Strafen",
-                "body": "Bei dir sind noch %s offen. Bitte so schnell wie möglich zahlen."
-            },
-            "state-change": {
-                "title": "Eine deiner Strafen hat sich geändert",
-                "body-payed": "Du hast eine Strafe von %1$s bezahlt (%2$s).",
-                "body-unpayed": "%1$s, %2$s ist noch offen.",
-                "body-deleted": "%1$s, %2$s wurde gelöscht."
-            }
-        }
-    },
-    "fineAmount": {
-        "item": {
-            "type": {
-                "crateOfBeer": "Kasten Bier",
-                "crateOfBeer?count=%s": {
-                    "one": "Ein Kasten Bier",
-                    "other": "%s Kästen Bier"
-                },
-                "crateOfBeerWithoutCount?count=%s": {
-                    "one": "Kasten Bier",
-                    "other": "Kästen Bier"
-                }
-            }
-        }
-    },
-    "fineTemplateRepetition": {
-        "item": {
-            "minute": "Minute",
-            "minute?count=%s": {
-                "one": "1 Minute",
-                "other": "%s Minuten"
-            },
-            "minuteWithoutCount?count=%s": {
-                "one": "Minute",
-                "other": "Minuten"
-            },
-            "day": "Tag",
-            "day?count=%s": {
-                "one": "1 Tag",
-                "other": "%s Tage"
-            },
-            "dayWithoutCount?count=%s": {
-                "one": "Tag",
-                "other": "Tage"
-            },
-            "item": "Teil",
-            "item?count=%s": {
-                "one": "1 Teil",
-                "other": "%s Teile"
-            },
-            "itemWithoutCount?count=%s": {
-                "one": "Teil",
-                "other": "Teile"
-            },
-            "count": "Anzahl",
-            "count?count=%s": {
-                "one": "1 mal",
-                "other": "%s mal"
-            },
-            "countWithoutCount?count=%s": {
-                "one": "mal",
-                "other": "mal"
-            }
-        }
-    },
-    "payedState": {
-        "payed": "Bezahlt",
-        "notPayed": "Offen"
-    },
-    "userRole": {
-        "personManager": "Personenmanager",
-        "fineTemplateManager": "Strafvorlagenmanager",
-        "fineManager": "Strafenmanager",
-        "teamManager": "Teammanager"
-    }
-}