@stevenkellner/team-conduct-api 1.0.22 → 1.0.23

package/lib/src/types/Localization.d.ts

@@ -1,75 +1,220 @@
-import { Configuration } from './Configuration';
-export declare const localizationKey: {
-    notification: {
-        fine: {
-            new: {
-                title: string;
-                body: string;
+import { Pluralization } from './Pluralization';
+export declare const localizations: {
+    en: {
+        notification: {
+            fine: {
+                new: {
+                    title: string;
+                    body: string;
+                };
+                reminder: {
+                    title: string;
+                    body: string;
+                };
+                stateChange: {
+                    title: string;
+                    bodyPayed: string;
+                    bodyUnpayed: string;
+                    bodyDeleted: string;
+                };
             };
-            reminder: {
-                title: string;
-                body: string;
+        };
+        fineAmount: {
+            item: {
+                type: {
+                    crateOfBeer: {
+                        name: string;
+                        withCount: Pluralization;
+                        withoutCount: Pluralization;
+                    };
+                };
             };
-            stateChange: {
-                title: string;
-                bodyPayed: string;
-                bodyUnpayed: string;
-                bodyDeleted: string;
+        };
+        fineTemplateRepetition: {
+            item: {
+                minute: {
+                    name: string;
+                    withCount: Pluralization;
+                    withoutCount: Pluralization;
+                };
+                day: {
+                    name: string;
+                    withCount: Pluralization;
+                    withoutCount: Pluralization;
+                };
+                item: {
+                    name: string;
+                    withCount: Pluralization;
+                    withoutCount: Pluralization;
+                };
+                count: {
+                    name: string;
+                    withCount: Pluralization;
+                    withoutCount: Pluralization;
+                };
             };
         };
+        payedState: {
+            payed: string;
+            notPayed: string;
+        };
+        userRole: {
+            personManager: string;
+            fineTemplateManager: string;
+            fineManager: string;
+            teamManager: string;
+        };
     };
-    fineAmount: {
-        item: {
-            type: {
-                crateOfBeer: string;
+    de: {
+        notification: {
+            fine: {
+                new: {
+                    title: string;
+                    body: string;
+                };
+                reminder: {
+                    title: string;
+                    body: string;
+                };
+                stateChange: {
+                    title: string;
+                    bodyPayed: string;
+                    bodyUnpayed: string;
+                    bodyDeleted: string;
+                };
             };
         };
-    };
-    fineTemplateRepetition: {
-        item: {
-            minute: string;
-            day: string;
-            item: string;
-            count: string;
+        fineAmount: {
+            item: {
+                type: {
+                    crateOfBeer: {
+                        name: string;
+                        withCount: Pluralization;
+                        withoutCount: Pluralization;
+                    };
+                };
+            };
         };
-    };
-    payedState: {
-        payed: string;
-        notPayed: string;
-    };
-    userRole: {
-        personManager: string;
-        fineTemplateManager: string;
-        fineManager: string;
-        teamManager: string;
-    };
-};
-export declare const localizationNKey: {
-    fineAmount: {
-        item: {
-            type: {
-                crateOfBeer: string;
-                crateOfBeerWithoutCount: string;
+        fineTemplateRepetition: {
+            item: {
+                minute: {
+                    name: string;
+                    withCount: Pluralization;
+                    withoutCount: Pluralization;
+                };
+                day: {
+                    name: string;
+                    withCount: Pluralization;
+                    withoutCount: Pluralization;
+                };
+                item: {
+                    name: string;
+                    withCount: Pluralization;
+                    withoutCount: Pluralization;
+                };
+                count: {
+                    name: string;
+                    withCount: Pluralization;
+                    withoutCount: Pluralization;
+                };
             };
         };
-    };
-    fineTemplateRepetition: {
-        item: {
-            minute: string;
-            minuteWithoutCount: string;
-            day: string;
-            dayWithoutCount: string;
-            item: string;
-            itemWithoutCount: string;
-            count: string;
-            countWithoutCount: string;
+        payedState: {
+            payed: string;
+            notPayed: string;
+        };
+        userRole: {
+            personManager: string;
+            fineTemplateManager: string;
+            fineManager: string;
+            teamManager: string;
         };
     };
 };
+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 declare class ValueLocalization {
+    private readonly rawValues;
+    constructor(rawValues: Record<keyof typeof localizations, string>);
+    value(args?: Record<string, string>): string;
+}
+export declare class PluralLocalization {
+    private readonly pluralizations;
+    constructor(pluralizations: Record<keyof typeof localizations, Pluralization>);
+    value(count: number, args?: Record<string, string>): string;
+}
 export declare class Localization {
-    static readonly shared: Localization;
-    private constructor();
-    setLocale(locale: Configuration.Locale): void;
-    get(getKey: (key: typeof localizationKey) => string, ...args: string[]): string;
-    getN(getKey: (key: typeof localizationNKey) => string, count: number): string;
+    static locale: keyof typeof localizations;
+    static readonly shared: {
+        notification: {
+            fine: {
+                new: {
+                    title: ValueLocalization;
+                    body: ValueLocalization;
+                };
+                reminder: {
+                    title: ValueLocalization;
+                    body: ValueLocalization;
+                };
+                stateChange: {
+                    title: ValueLocalization;
+                    bodyPayed: ValueLocalization;
+                    bodyUnpayed: ValueLocalization;
+                    bodyDeleted: ValueLocalization;
+                };
+            };
+        };
+        fineAmount: {
+            item: {
+                type: {
+                    crateOfBeer: {
+                        name: ValueLocalization;
+                        withCount: PluralLocalization;
+                        withoutCount: PluralLocalization;
+                    };
+                };
+            };
+        };
+        fineTemplateRepetition: {
+            item: {
+                minute: {
+                    name: ValueLocalization;
+                    withCount: PluralLocalization;
+                    withoutCount: PluralLocalization;
+                };
+                day: {
+                    name: ValueLocalization;
+                    withCount: PluralLocalization;
+                    withoutCount: PluralLocalization;
+                };
+                item: {
+                    name: ValueLocalization;
+                    withCount: PluralLocalization;
+                    withoutCount: PluralLocalization;
+                };
+                count: {
+                    name: ValueLocalization;
+                    withCount: PluralLocalization;
+                    withoutCount: PluralLocalization;
+                };
+            };
+        };
+        payedState: {
+            payed: ValueLocalization;
+            notPayed: ValueLocalization;
+        };
+        userRole: {
+            personManager: ValueLocalization;
+            fineTemplateManager: ValueLocalization;
+            fineManager: ValueLocalization;
+            teamManager: ValueLocalization;
+        };
+    };
+    private static getSubLocalization;
 }

package/lib/src/types/Localization.js

@@ -1,128 +1,76 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Localization = exports.localizationNKey = exports.localizationKey = void 0;
-const i18n = __importStar(require("i18n"));
-const Configuration_1 = require("./Configuration");
-exports.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'
-    }
+exports.Localization = exports.PluralLocalization = exports.ValueLocalization = exports.localizations = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const en_1 = require("../locales/en");
+const de_1 = require("../locales/de");
+const Pluralization_1 = require("./Pluralization");
+exports.localizations = {
+    en: en_1.localizationEN,
+    de: de_1.localizationDE
 };
-exports.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'
+class ValueLocalization {
+    rawValues;
+    constructor(rawValues) {
+        this.rawValues = rawValues;
+    }
+    value(args = {}) {
+        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;
     }
-};
-class Localization {
-    static shared = new Localization();
-    constructor() {
-        i18n.configure({
-            locales: Configuration_1.Configuration.Locale.all,
-            defaultLocale: 'en',
-            directory: 'src/locales',
-            objectNotation: true
-        });
+}
+exports.ValueLocalization = ValueLocalization;
+class PluralLocalization {
+    pluralizations;
+    constructor(pluralizations) {
+        this.pluralizations = pluralizations;
     }
-    setLocale(locale) {
-        i18n.setLocale(locale);
+    value(count, args = {}) {
+        const valueLocalization = new ValueLocalization((0, typescript_common_functionality_1.mapRecord)(this.pluralizations, pluralization => pluralization.get(count)));
+        return valueLocalization.value({
+            count: `${count}`,
+            ...args
+        });
     }
-    get(getKey, ...args) {
-        const key = getKey(exports.localizationKey);
-        return i18n.__(key, ...args);
+}
+exports.PluralLocalization = PluralLocalization;
+function swap1stAnd2ndLevel(record) {
+    const swapped = {};
+    for (const key1 of (0, typescript_common_functionality_1.keys)(record)) {
+        for (const key2 of (0, typescript_common_functionality_1.keys)(record[key1])) {
+            if (!(key2 in swapped))
+                swapped[key2] = {};
+            swapped[key2][key1] = record[key1][key2];
+        }
     }
-    getN(getKey, count) {
-        const key = getKey(exports.localizationNKey);
-        return i18n.__n(key, count);
+    return swapped;
+}
+class Localization {
+    static locale = 'en';
+    static shared = Localization.getSubLocalization(exports.localizations);
+    static getSubLocalization(_localizations) {
+        const _localizationValue = (0, typescript_common_functionality_1.values)(_localizations);
+        if (_localizationValue.length === 0)
+            return {};
+        if (typeof _localizationValue[0] === 'object' && !(_localizationValue[0] instanceof Pluralization_1.Pluralization)) {
+            const swapped = swap1stAnd2ndLevel(_localizations);
+            return (0, typescript_common_functionality_1.mapRecord)(swapped, subLocalization => Localization.getSubLocalization(subLocalization));
+        }
+        if (typeof _localizationValue[0] === 'string')
+            return new ValueLocalization(_localizations);
+        if (_localizationValue[0] instanceof Pluralization_1.Pluralization)
+            return new PluralLocalization(_localizations);
+        throw new Error('Invalid localization structure');
     }
 }
 exports.Localization = Localization;

package/lib/src/types/PayedState.js

@@ -7,7 +7,7 @@ var PayedState;
 (function (PayedState) {
     PayedState.all = ['payed', 'notPayed'];
     function formatted(state) {
-        return Localization_1.Localization.shared.get(key => key.payedState[state]);
+        return Localization_1.Localization.shared.payedState[state].value();
     }
     PayedState.formatted = formatted;
     function toggled(state) {

package/lib/src/types/Pluralization.d.ts

@@ -0,0 +1,17 @@
+export declare class Pluralization {
+    private readonly zero;
+    private readonly one;
+    private readonly two;
+    private readonly few;
+    private readonly many;
+    private readonly other;
+    constructor(countLocals: {
+        zero?: string;
+        one?: string;
+        two?: string;
+        few?: string;
+        many?: string;
+        other: string;
+    });
+    get(count: number): string;
+}

package/lib/src/types/Pluralization.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pluralization = void 0;
+class Pluralization {
+    zero;
+    one;
+    two;
+    few;
+    many;
+    other;
+    constructor(countLocals) {
+        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;
+    }
+    get(count) {
+        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;
+    }
+}
+exports.Pluralization = Pluralization;

package/lib/src/types/UserRole.js

@@ -18,7 +18,7 @@ var UserRole;
             'fine-manager': 'fineManager',
             'team-manager': 'teamManager'
         };
-        return Localization_1.Localization.shared.get(key => key.userRole[localizationKeyMap[role]]);
+        return Localization_1.Localization.shared.userRole[localizationKeyMap[role]].value();
     }
     UserRole.formatted = formatted;
     UserRole.builder = new typescript_common_functionality_1.ValueTypeBuilder();

package/lib/src/types/index.d.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/types/index.js

@@ -27,6 +27,7 @@ __exportStar(require("./PayedState"), exports);
 __exportStar(require("./Person"), exports);
 __exportStar(require("./PersonPrivateProperties"), exports);
 __exportStar(require("./PersonSignInProperties"), exports);
+__exportStar(require("./Pluralization"), exports);
 __exportStar(require("./Team"), exports);
 __exportStar(require("./User"), exports);
 __exportStar(require("./UserRole"), exports);

package/lib/test/localization-utils.d.ts

@@ -1,12 +1 @@
-import { localizationKey, localizationNKey } from '../src/types/Localization';
-export declare function localizationWithoutDefault<T extends Record<string, unknown>>(record: T): Exclude<T, 'default'>;
 export declare function hasSameKeys(record1: Record<string, unknown>, record2: Record<string, unknown>): void;
-export declare class TestedKeys {
-    private tested;
-    constructor(localization: Record<string, unknown>);
-    private mapCheckTestedRecord;
-    checkAllTested(): void;
-    test(getKey: (key: typeof localizationKey) => string, expected: string): void;
-    testArgs(getKey: (key: typeof localizationKey) => string, args: string[], expected: string): void;
-    testN(getKey: (key: typeof localizationNKey) => string, count: number, expected: string): void;
-}

package/lib/test/localization-utils.js

@@ -1,16 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestedKeys = void 0;
-exports.localizationWithoutDefault = localizationWithoutDefault;
 exports.hasSameKeys = hasSameKeys;
 const core_1 = require("@assertive-ts/core");
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-const Localization_1 = require("../src/types/Localization");
-function localizationWithoutDefault(record) {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { default: _, ...rest } = record;
-    return rest;
-}
+const src_1 = require("../src");
 function hasSameKeys(record1, record2) {
     (0, core_1.expect)((0, typescript_common_functionality_1.keys)(record1)).toHaveSameMembers((0, typescript_common_functionality_1.keys)(record2));
     for (const key of (0, typescript_common_functionality_1.keys)(record1)) {
@@ -18,7 +11,10 @@ function hasSameKeys(record1, record2) {
             (0, core_1.expect)(record2[key]).not.toBeUndefined();
             (0, core_1.expect)(typeof record2[key]).toBeEqual('object');
             (0, core_1.expect)(record1[key]).not.toBeNull();
-            hasSameKeys(record1[key], record2[key]);
+            if (record1[key] instanceof src_1.Pluralization)
+                (0, core_1.expect)(record2[key]).toBeInstanceOf(src_1.Pluralization);
+            else
+                hasSameKeys(record1[key], record2[key]);
         }
         else {
             (0, core_1.expect)(typeof record1[key]).toBeEqual('string');
@@ -26,43 +22,3 @@ function hasSameKeys(record1, record2) {
         }
     }
 }
-class TestedKeys {
-    tested;
-    constructor(localization) {
-        this.tested = this.mapCheckTestedRecord(localizationWithoutDefault(localization));
-    }
-    mapCheckTestedRecord(record) {
-        function getKeyList(record, key) {
-            return (0, typescript_common_functionality_1.keys)(record).flatMap(k => {
-                if (typeof record[k] === 'object' && record[k] !== null)
-                    return getKeyList(record[k], `${key}${k}.`);
-                else
-                    return `${key}${k}`;
-            });
-        }
-        const testedRecord = {};
-        for (const key of getKeyList(record, ''))
-            testedRecord[key] = false;
-        return testedRecord;
-    }
-    checkAllTested() {
-        for (const value of (0, typescript_common_functionality_1.values)(this.tested))
-            (0, core_1.expect)(value).toBeEqual(true);
-    }
-    test(getKey, expected) {
-        this.tested[getKey(Localization_1.localizationKey)] = true;
-        (0, core_1.expect)(Localization_1.Localization.shared.get(getKey)).toBeEqual(expected);
-    }
-    testArgs(getKey, args, expected) {
-        this.tested[getKey(Localization_1.localizationKey)] = true;
-        (0, core_1.expect)(Localization_1.Localization.shared.get(getKey, ...args)).toBeEqual(expected);
-    }
-    testN(getKey, count, expected) {
-        if (count === 1)
-            this.tested[`${getKey(Localization_1.localizationNKey)}.one`] = true;
-        else
-            this.tested[`${getKey(Localization_1.localizationNKey)}.other`] = true;
-        (0, core_1.expect)(Localization_1.Localization.shared.getN(getKey, count)).toBeEqual(expected);
-    }
-}
-exports.TestedKeys = TestedKeys;