@glissandoo/lib 1.123.2 → 1.124.0-dev.219.1

package/helpers/notifications/index.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userNotificationSettings = exports.notificationMultiplePractice = exports.notificationSinglePractice = exports.notificationOther = exports.notificationPerformance = exports.editScopeToAction = exports.NotificationEventActions = exports.notificationActionsBadges = void 0;
+const event_1 = require("../../functions/event");
+const types_1 = require("../../models/Notification/types");
+const types_2 = require("../../models/User/types");
+const badges_1 = require("../badges");
+exports.notificationActionsBadges = {
+    [badges_1.BadgesTypes.AccPerformances]: {
+        firstLevel: types_1.NotificationActions.BadgeAccPerformancesFirstLevel,
+        upLevel: types_1.NotificationActions.BadgeAccPerformancesUpLevel,
+    },
+    [badges_1.BadgesTypes.AccPractices]: {
+        firstLevel: types_1.NotificationActions.BadgeAccPracticesFirstLevel,
+        upLevel: types_1.NotificationActions.BadgeAccPracticesUpLevel,
+    },
+    [badges_1.BadgesTypes.AnswerEvents]: {
+        firstLevel: types_1.NotificationActions.BadgeAnswerEventsFirstLevel,
+        upLevel: types_1.NotificationActions.BadgeAnswerEventsUpLevel,
+    },
+    [badges_1.BadgesTypes.StrikePractices]: {
+        firstLevel: types_1.NotificationActions.BadgeStrikePracticesFirstLevel,
+        upLevel: types_1.NotificationActions.BadgeStrikePracticesUpLevel,
+    },
+};
+var NotificationEventActions;
+(function (NotificationEventActions) {
+    NotificationEventActions["Create"] = "create";
+    NotificationEventActions["Cancel"] = "cancel";
+    NotificationEventActions["EditAttendance"] = "editAttendance";
+    NotificationEventActions["EditComments"] = "editComments";
+    NotificationEventActions["EditDatetime"] = "editDatetime";
+    NotificationEventActions["EditLocality"] = "editLocality";
+    NotificationEventActions["EditRepertory"] = "editRepertory";
+    NotificationEventActions["EditStage"] = "editStage";
+    NotificationEventActions["EditTitle"] = "editTitle";
+    NotificationEventActions["EditResponseDeadline"] = "editResponseDeadline";
+    NotificationEventActions["EditImages"] = "editImages";
+    NotificationEventActions["EditAttachments"] = "editAttachments";
+    NotificationEventActions["EditQuestions"] = "editQuestions";
+    NotificationEventActions["EditReminders"] = "editReminders";
+    NotificationEventActions["AddPlayers"] = "addPlayers";
+    NotificationEventActions["RemovePlayers"] = "removePlayers";
+    NotificationEventActions["ConfirmAssistance"] = "confirmAssistance";
+    NotificationEventActions["DeclineAssistance"] = "declineAssistance";
+    NotificationEventActions["ConfirmAssistanceByAdmin"] = "confirmAssistanceByAdmin";
+    NotificationEventActions["DeclineAssistanceByAdmin"] = "declineAssistanceByAdmin";
+    NotificationEventActions["ConfirmInterest"] = "confirmInterest";
+    NotificationEventActions["LoseInterest"] = "loseInterest";
+    NotificationEventActions["ConfirmInterestByAdmin"] = "confirmInterestByAdmin";
+    NotificationEventActions["LoseInterestByAdmin"] = "loseInterestByAdmin";
+    NotificationEventActions["SelectionSelected"] = "selectionSelected";
+    NotificationEventActions["SelectionDeselected"] = "selectionDeselected";
+    NotificationEventActions["Reminder"] = "reminder";
+    NotificationEventActions["ReminderDatetimeToConfirmed"] = "reminderDatetimeToConfirmed";
+    NotificationEventActions["ReminderDeadlineSoonToPending"] = "reminderDeadlineSoonToPending";
+    NotificationEventActions["ReminderDeadlineEndedInSelectionModeOpen"] = "reminderDeadlineEndedInSelectionModeOpenEvent";
+    NotificationEventActions["ReminderDeadlineEndedInSelectionModeClosedOrNotActive"] = "reminderDeadlineEndedInSelectionModeClosedOrNotActiveEvent";
+    NotificationEventActions["ReminderRollcall"] = "reminderRollcall";
+})(NotificationEventActions || (exports.NotificationEventActions = NotificationEventActions = {}));
+exports.editScopeToAction = {
+    [event_1.EventoFbFunctionsTypes.EditScope.Title]: NotificationEventActions.EditTitle,
+    [event_1.EventoFbFunctionsTypes.EditScope.Locality]: NotificationEventActions.EditLocality,
+    [event_1.EventoFbFunctionsTypes.EditScope.Comments]: NotificationEventActions.EditComments,
+    [event_1.EventoFbFunctionsTypes.EditScope.Attendance]: NotificationEventActions.EditAttendance,
+    [event_1.EventoFbFunctionsTypes.EditScope.Stage]: NotificationEventActions.EditStage,
+    [event_1.EventoFbFunctionsTypes.EditScope.Images]: NotificationEventActions.EditImages,
+    [event_1.EventoFbFunctionsTypes.EditScope.Attachments]: NotificationEventActions.EditAttachments,
+    [event_1.EventoFbFunctionsTypes.EditScope.Questions]: NotificationEventActions.EditQuestions,
+    [event_1.EventoFbFunctionsTypes.EditScope.Reminders]: NotificationEventActions.EditQuestions,
+};
+exports.notificationPerformance = {
+    [NotificationEventActions.Cancel]: types_1.NotificationActions.PerformanceCancel,
+    [NotificationEventActions.Create]: types_1.NotificationActions.PerformanceCreate,
+    [NotificationEventActions.EditAttendance]: types_1.NotificationActions.PerformanceEditAttendance,
+    [NotificationEventActions.EditComments]: types_1.NotificationActions.PerformanceEditComments,
+    [NotificationEventActions.EditDatetime]: types_1.NotificationActions.PerformanceEditDatetime,
+    [NotificationEventActions.EditLocality]: types_1.NotificationActions.PerformanceEditLocality,
+    [NotificationEventActions.EditRepertory]: types_1.NotificationActions.PerformanceEditRepertory,
+    [NotificationEventActions.EditTitle]: types_1.NotificationActions.PerformanceEditTitle,
+    [NotificationEventActions.EditStage]: types_1.NotificationActions.PerformanceEditStage,
+    [NotificationEventActions.EditQuestions]: types_1.NotificationActions.PerformanceEditQuestions,
+    [NotificationEventActions.EditResponseDeadline]: types_1.NotificationActions.PerformanceEditResponseDeadline,
+    [NotificationEventActions.EditImages]: types_1.NotificationActions.PerformanceEditImages,
+    [NotificationEventActions.EditAttachments]: types_1.NotificationActions.PerformanceEditAttachments,
+    [NotificationEventActions.EditReminders]: types_1.NotificationActions.PerformanceEditReminders,
+    [NotificationEventActions.AddPlayers]: types_1.NotificationActions.PerformancePlayersAdd,
+    [NotificationEventActions.RemovePlayers]: types_1.NotificationActions.PerformancePlayersRemove,
+    [NotificationEventActions.ConfirmAssistance]: types_1.NotificationActions.PerformanceAssistanceConfirm,
+    [NotificationEventActions.DeclineAssistance]: types_1.NotificationActions.PerformanceAssistanceDecline,
+    [NotificationEventActions.ConfirmAssistanceByAdmin]: types_1.NotificationActions.PerformanceAssistanceConfirmByAdmin,
+    [NotificationEventActions.DeclineAssistanceByAdmin]: types_1.NotificationActions.PerformanceAssistanceDeclineByAdmin,
+    [NotificationEventActions.ConfirmInterest]: types_1.NotificationActions.PerformanceInterestConfirm,
+    [NotificationEventActions.LoseInterest]: types_1.NotificationActions.PerformanceInterestLose,
+    [NotificationEventActions.ConfirmInterestByAdmin]: types_1.NotificationActions.PerformanceInterestConfirmByAdmin,
+    [NotificationEventActions.LoseInterestByAdmin]: types_1.NotificationActions.PerformanceInterestLoseByAdmin,
+    [NotificationEventActions.SelectionSelected]: types_1.NotificationActions.PerformanceSelectionSelect,
+    [NotificationEventActions.SelectionDeselected]: types_1.NotificationActions.PerformanceSelectionDeselect,
+    [NotificationEventActions.Reminder]: types_1.NotificationActions.PerformanceReminder,
+    [NotificationEventActions.ReminderDatetimeToConfirmed]: types_1.NotificationActions.PerformanceReminderDatetimeToConfirmed,
+    [NotificationEventActions.ReminderDeadlineSoonToPending]: types_1.NotificationActions.PerformanceReminderDeadlineSoonToPending,
+    [NotificationEventActions.ReminderDeadlineEndedInSelectionModeOpen]: types_1.NotificationActions.PerformanceReminderDeadlineEndedInSelectionModeOpen,
+    [NotificationEventActions.ReminderDeadlineEndedInSelectionModeClosedOrNotActive]: types_1.NotificationActions.PerformanceReminderDeadlineEndedInSelectionModeClosedOrNotActive,
+    [NotificationEventActions.ReminderRollcall]: types_1.NotificationActions.PerformanceRollCallReminder,
+};
+exports.notificationOther = {
+    [NotificationEventActions.Cancel]: types_1.NotificationActions.OtherCancel,
+    [NotificationEventActions.Create]: types_1.NotificationActions.OtherCreate,
+    [NotificationEventActions.EditAttendance]: types_1.NotificationActions.OtherEditAttendance,
+    [NotificationEventActions.EditComments]: types_1.NotificationActions.OtherEditComments,
+    [NotificationEventActions.EditDatetime]: types_1.NotificationActions.OtherEditDatetime,
+    [NotificationEventActions.EditLocality]: types_1.NotificationActions.OtherEditLocality,
+    [NotificationEventActions.EditRepertory]: types_1.NotificationActions.OtherEditRepertory,
+    [NotificationEventActions.EditTitle]: types_1.NotificationActions.OtherEditTitle,
+    [NotificationEventActions.EditStage]: types_1.NotificationActions.OtherEditStage,
+    [NotificationEventActions.EditQuestions]: types_1.NotificationActions.OtherEditQuestions,
+    [NotificationEventActions.EditResponseDeadline]: types_1.NotificationActions.OtherEditResponseDeadline,
+    [NotificationEventActions.EditImages]: types_1.NotificationActions.OtherEditImages,
+    [NotificationEventActions.EditAttachments]: types_1.NotificationActions.OtherEditAttachments,
+    [NotificationEventActions.EditReminders]: types_1.NotificationActions.OtherEditReminders,
+    [NotificationEventActions.AddPlayers]: types_1.NotificationActions.OtherPlayersAdd,
+    [NotificationEventActions.RemovePlayers]: types_1.NotificationActions.OtherPlayersRemove,
+    [NotificationEventActions.ConfirmAssistance]: types_1.NotificationActions.OtherAssistanceConfirm,
+    [NotificationEventActions.DeclineAssistance]: types_1.NotificationActions.OtherAssistanceDecline,
+    [NotificationEventActions.ConfirmAssistanceByAdmin]: types_1.NotificationActions.OtherAssistanceConfirmByAdmin,
+    [NotificationEventActions.DeclineAssistanceByAdmin]: types_1.NotificationActions.OtherAssistanceDeclineByAdmin,
+    [NotificationEventActions.ConfirmInterest]: types_1.NotificationActions.OtherInterestConfirm,
+    [NotificationEventActions.LoseInterest]: types_1.NotificationActions.OtherInterestLose,
+    [NotificationEventActions.ConfirmInterestByAdmin]: types_1.NotificationActions.OtherInterestConfirmByAdmin,
+    [NotificationEventActions.LoseInterestByAdmin]: types_1.NotificationActions.OtherInterestLoseByAdmin,
+    [NotificationEventActions.SelectionSelected]: types_1.NotificationActions.OtherSelectionSelect,
+    [NotificationEventActions.SelectionDeselected]: types_1.NotificationActions.OtherSelectionDeselect,
+    [NotificationEventActions.Reminder]: types_1.NotificationActions.OtherReminder,
+    [NotificationEventActions.ReminderDatetimeToConfirmed]: types_1.NotificationActions.OtherReminderDatetimeToConfirmed,
+    [NotificationEventActions.ReminderDeadlineSoonToPending]: types_1.NotificationActions.OtherReminderDeadlineSoonToPending,
+    [NotificationEventActions.ReminderDeadlineEndedInSelectionModeOpen]: types_1.NotificationActions.OtherReminderDeadlineEndedInSelectionModeOpen,
+    [NotificationEventActions.ReminderDeadlineEndedInSelectionModeClosedOrNotActive]: types_1.NotificationActions.OtherReminderDeadlineEndedInSelectionModeClosedOrNotActive,
+    [NotificationEventActions.ReminderRollcall]: types_1.NotificationActions.OtherRollCallReminder,
+};
+exports.notificationSinglePractice = {
+    [NotificationEventActions.Cancel]: types_1.NotificationActions.PracticeCancel,
+    [NotificationEventActions.Create]: types_1.NotificationActions.PracticeCreate,
+    [NotificationEventActions.EditAttendance]: types_1.NotificationActions.PracticeEditAttendance,
+    [NotificationEventActions.EditComments]: types_1.NotificationActions.PracticeEditComments,
+    [NotificationEventActions.EditDatetime]: types_1.NotificationActions.PracticeEditDatetime,
+    [NotificationEventActions.EditLocality]: types_1.NotificationActions.PracticeEditLocality,
+    [NotificationEventActions.EditRepertory]: types_1.NotificationActions.PracticeEditRepertory,
+    [NotificationEventActions.EditTitle]: types_1.NotificationActions.PracticeEditTitle,
+    [NotificationEventActions.EditStage]: types_1.NotificationActions.PracticeEditStage,
+    [NotificationEventActions.EditResponseDeadline]: types_1.NotificationActions.PracticeEditResponseDeadline,
+    [NotificationEventActions.EditImages]: types_1.NotificationActions.PracticeEditImages,
+    [NotificationEventActions.EditAttachments]: types_1.NotificationActions.PracticeEditAttachments,
+    [NotificationEventActions.EditQuestions]: types_1.NotificationActions.PracticeEditQuestions,
+    [NotificationEventActions.EditReminders]: types_1.NotificationActions.PracticeEditReminders,
+    [NotificationEventActions.AddPlayers]: types_1.NotificationActions.PracticePlayersAdd,
+    [NotificationEventActions.RemovePlayers]: types_1.NotificationActions.PracticePlayersRemove,
+    [NotificationEventActions.ConfirmAssistance]: types_1.NotificationActions.PracticeAssistanceConfirm,
+    [NotificationEventActions.DeclineAssistance]: types_1.NotificationActions.PracticeAssistanceDecline,
+    [NotificationEventActions.ConfirmAssistanceByAdmin]: types_1.NotificationActions.PracticeAssistanceConfirmByAdmin,
+    [NotificationEventActions.DeclineAssistanceByAdmin]: types_1.NotificationActions.PracticeAssistanceDeclineByAdmin,
+    [NotificationEventActions.ConfirmInterest]: types_1.NotificationActions.PracticeInterestConfirm,
+    [NotificationEventActions.LoseInterest]: types_1.NotificationActions.PracticeInterestLose,
+    [NotificationEventActions.ConfirmInterestByAdmin]: types_1.NotificationActions.PracticeInterestConfirmByAdmin,
+    [NotificationEventActions.LoseInterestByAdmin]: types_1.NotificationActions.PracticeInterestLoseByAdmin,
+    [NotificationEventActions.SelectionSelected]: types_1.NotificationActions.PracticeSelectionSelect,
+    [NotificationEventActions.SelectionDeselected]: types_1.NotificationActions.PracticeSelectionDeselect,
+    [NotificationEventActions.Reminder]: types_1.NotificationActions.PracticeReminder,
+    [NotificationEventActions.ReminderDatetimeToConfirmed]: types_1.NotificationActions.PracticeReminderDatetimeToConfirmed,
+    [NotificationEventActions.ReminderDeadlineSoonToPending]: types_1.NotificationActions.PracticeReminderDeadlineSoonToPending,
+    [NotificationEventActions.ReminderDeadlineEndedInSelectionModeOpen]: types_1.NotificationActions.PracticeReminderDeadlineEndedInSelectionModeOpen,
+    [NotificationEventActions.ReminderDeadlineEndedInSelectionModeClosedOrNotActive]: types_1.NotificationActions.PracticeReminderDeadlineEndedInSelectionModeClosedOrNotActive,
+    [NotificationEventActions.ReminderRollcall]: types_1.NotificationActions.PracticeRollCallReminder,
+};
+exports.notificationMultiplePractice = {
+    [NotificationEventActions.Cancel]: types_1.NotificationActions.PracticesCancel,
+    [NotificationEventActions.Create]: types_1.NotificationActions.PracticesCreate,
+    [NotificationEventActions.EditAttendance]: types_1.NotificationActions.PracticesEditAttendance,
+    [NotificationEventActions.EditComments]: types_1.NotificationActions.PracticesEditComments,
+    [NotificationEventActions.EditDatetime]: types_1.NotificationActions.PracticesEditDatetime,
+    [NotificationEventActions.EditLocality]: types_1.NotificationActions.PracticesEditLocality,
+    [NotificationEventActions.EditRepertory]: types_1.NotificationActions.PracticesEditRepertory,
+    [NotificationEventActions.EditTitle]: types_1.NotificationActions.PracticesEditTitle,
+    [NotificationEventActions.EditStage]: types_1.NotificationActions.PracticesEditStage,
+    [NotificationEventActions.EditResponseDeadline]: types_1.NotificationActions.PracticesEditResponseDeadline,
+    [NotificationEventActions.EditImages]: types_1.NotificationActions.PracticesEditImages,
+    [NotificationEventActions.EditAttachments]: types_1.NotificationActions.PracticesEditAttachments,
+    [NotificationEventActions.EditQuestions]: types_1.NotificationActions.PracticesEditQuestions,
+    [NotificationEventActions.EditReminders]: types_1.NotificationActions.PracticesEditReminders,
+    [NotificationEventActions.AddPlayers]: types_1.NotificationActions.PracticesPlayersAdd,
+    [NotificationEventActions.RemovePlayers]: types_1.NotificationActions.PracticesPlayersRemove,
+    [NotificationEventActions.ConfirmAssistance]: types_1.NotificationActions.PracticeAssistanceConfirm,
+    [NotificationEventActions.DeclineAssistance]: types_1.NotificationActions.PracticeAssistanceDecline,
+    [NotificationEventActions.ConfirmAssistanceByAdmin]: types_1.NotificationActions.PracticeAssistanceConfirmByAdmin,
+    [NotificationEventActions.DeclineAssistanceByAdmin]: types_1.NotificationActions.PracticeAssistanceDeclineByAdmin,
+    [NotificationEventActions.ConfirmInterest]: types_1.NotificationActions.PracticeInterestConfirm,
+    [NotificationEventActions.LoseInterest]: types_1.NotificationActions.PracticeInterestLose,
+    [NotificationEventActions.ConfirmInterestByAdmin]: types_1.NotificationActions.PracticeInterestConfirmByAdmin,
+    [NotificationEventActions.LoseInterestByAdmin]: types_1.NotificationActions.PracticeInterestLoseByAdmin,
+    [NotificationEventActions.SelectionSelected]: types_1.NotificationActions.PracticeSelectionSelect,
+    [NotificationEventActions.SelectionDeselected]: types_1.NotificationActions.PracticeSelectionDeselect,
+    [NotificationEventActions.Reminder]: types_1.NotificationActions.PracticeReminder,
+    [NotificationEventActions.ReminderDatetimeToConfirmed]: types_1.NotificationActions.PracticeReminderDatetimeToConfirmed,
+    [NotificationEventActions.ReminderDeadlineSoonToPending]: types_1.NotificationActions.PracticeReminderDeadlineSoonToPending,
+    [NotificationEventActions.ReminderDeadlineEndedInSelectionModeOpen]: types_1.NotificationActions.PracticeReminderDeadlineEndedInSelectionModeOpen,
+    [NotificationEventActions.ReminderDeadlineEndedInSelectionModeClosedOrNotActive]: types_1.NotificationActions.PracticeReminderDeadlineEndedInSelectionModeClosedOrNotActive,
+    [NotificationEventActions.ReminderRollcall]: types_1.NotificationActions.PracticeRollCallReminder,
+};
+exports.userNotificationSettings = {
+    [types_2.UserNotificationSettings.AttendanceConfirmed]: [
+        types_1.NotificationActions.PerformanceAssistanceConfirm,
+        types_1.NotificationActions.PracticeAssistanceConfirm,
+        types_1.NotificationActions.OtherAssistanceConfirm,
+    ],
+    [types_2.UserNotificationSettings.AttendanceDeclined]: [
+        types_1.NotificationActions.PerformanceAssistanceDecline,
+        types_1.NotificationActions.PracticeAssistanceDecline,
+        types_1.NotificationActions.OtherAssistanceDecline,
+    ],
+    [types_2.UserNotificationSettings.NewMembers]: [
+        types_1.NotificationActions.GroupPlayersJoin,
+        types_1.NotificationActions.GroupPlayersJoinPlayers,
+    ],
+    // [UserNotificationSettings.InterestConfirmed]: [
+    // 	NotificationActions.PerformanceInterestConfirm,
+    // 	NotificationActions.PracticeInterestConfirm,
+    // ],
+    // [UserNotificationSettings.InterestLost]: [
+    // 	NotificationActions.PerformanceInterestLose,
+    // 	NotificationActions.PracticeInterestLose,
+    // ],
+};

package/helpers/objects.d.ts

@@ -0,0 +1,15 @@
+export interface Ordered {
+    order: number;
+}
+export declare const mapToArray: <K extends string, V extends object, O extends Record<K, V | undefined>>(obj: O) => (O[`${Exclude<keyof O, symbol>}`] & {
+    id: keyof O;
+})[];
+export declare const orderedMapToArray: <K extends string, V extends {
+    order: number;
+}, O extends Record<K, V>>(obj: O) => Pick<O[`${Exclude<keyof O, symbol>}`] & {
+    id: keyof O;
+}, "id" | Exclude<keyof O[`${Exclude<keyof O, symbol>}`], "order">>[];
+export declare const map: <KIn extends string, VIn, KOut extends string, VOut>(obj: Record<KIn, VIn>, fn: (key: `${KIn}`, value: VIn, index?: number) => [KOut, VOut]) => Record<KOut, VOut>;
+export declare function filter<K extends string, V, S extends V>(obj: Record<K, V>, fn: (key: `${Exclude<K, symbol>}`, value: V, index?: number) => value is S): Record<`${Exclude<K, symbol>}`, S>;
+export declare function filter<K extends string, V>(obj: Record<K, V>, fn: (key: `${Exclude<K, symbol>}`, value: V, index?: number) => unknown): Record<`${Exclude<K, symbol>}`, V>;
+export declare const forEach: <K extends string, V>(obj: Record<K, V>, fn: (key: `${Exclude<K, symbol>}`, value: V, index?: number) => unknown) => void;

package/helpers/objects.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEach = exports.map = exports.orderedMapToArray = exports.mapToArray = void 0;
+exports.filter = filter;
+const lodash_1 = require("lodash");
+const ts_extras_1 = require("./ts-extras");
+const mapToArray = (obj) => {
+    return (0, ts_extras_1.objectEntries)(obj).map(([key, value]) => ({
+        ...value,
+        id: key,
+    }));
+};
+exports.mapToArray = mapToArray;
+const orderedMapToArray = (obj) => {
+    return (0, ts_extras_1.objectEntries)(obj)
+        .map(([key, value]) => ({
+        ...value,
+        id: key,
+    }))
+        .sort((a, b) => a.order - b.order)
+        .map((obj) => (0, lodash_1.omit)(obj, 'order'));
+};
+exports.orderedMapToArray = orderedMapToArray;
+const map = (obj, fn) => {
+    const entries = (0, ts_extras_1.objectEntries)(obj);
+    const mappedEntries = entries.map(([key, value], index) => fn(key, value, index));
+    return (0, ts_extras_1.objectFromEntries)(mappedEntries);
+};
+exports.map = map;
+function filter(obj, fn) {
+    const entries = Object.entries(obj);
+    // Note: We cast key back to the template literal type for the callback
+    const filteredEntries = entries.filter(([key, value], index) => fn(key, value, index));
+    return Object.fromEntries(filteredEntries);
+}
+const forEach = (obj, fn) => {
+    const entries = (0, ts_extras_1.objectEntries)(obj);
+    return entries.forEach(([key, value], index) => fn(key, value, index));
+};
+exports.forEach = forEach;

package/helpers/paymentForecast.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEventPaymentForecast = buildEventPaymentForecast;
+const types_1 = require("../models/Evento/Player/types");
+const types_2 = require("../models/Evento/types");
+const payoutRules_1 = require("./payoutRules");
+/**
+ * Computes the simulated ("forecast") payment rows shown in the event payments
+ * tab for players that don't yet have a real payment.
+ *
+ * Exclusion rules per player:
+ *  - The player already has a real payment whose id is NOT in `payout.expenses`
+ *    (`playerIdsWithNonExpensePayment`).
+ *  - `status === Declined` or `rollcall === Declined`.
+ *  - When `selectionMode === Closed`, require `selected === true` (rejects
+ *    `false` and `null`).
+ *  - The payout rules engine returns `excluded` (PlayerExclude rule).
+ *
+ * Returns an empty array when no `payout` is configured for the event.
+ */
+function buildEventPaymentForecast({ players, payout, playerIdsWithNonExpensePayment, selectionMode, customFieldsByPlayerId, }) {
+    if (!payout)
+        return [];
+    const requireSelected = selectionMode === types_2.EventSelectionMode.Closed;
+    const result = [];
+    for (const player of players) {
+        if (playerIdsWithNonExpensePayment.has(player.id))
+            continue;
+        if (player.status === types_1.EventPlayerStatus.Declined)
+            continue;
+        if (player.rollcall === types_1.EventPlayerStatus.Declined)
+            continue;
+        if (requireSelected && player.selected !== true)
+            continue;
+        const input = {
+            id: player.id,
+            mainInstrument: player.mainInstrument ?? '',
+            isGuest: player.isGuest,
+            customFields: customFieldsByPlayerId?.get(player.id) ?? {},
+        };
+        const evaluation = (0, payoutRules_1.evaluateRulesForPlayer)(input, payout.rules ?? [], payout.importByMember);
+        if (evaluation.excluded)
+            continue;
+        result.push({
+            playerId: player.id,
+            displayName: player.displayName,
+            mainInstrument: player.mainInstrument ?? '',
+            photoURL: player.photoURL ?? '',
+            isGuest: player.isGuest,
+            currency: payout.currency,
+            baseAmount: evaluation.baseAmount,
+            totalAmount: evaluation.finalAmount,
+            appliedRules: evaluation.appliedRules,
+        });
+    }
+    return result;
+}

package/helpers/payoutRules.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateCondition = evaluateCondition;
+exports.ruleMatchesPlayer = ruleMatchesPlayer;
+exports.evaluateRulesForPlayer = evaluateRulesForPlayer;
+const payoutRule_1 = require("../types/payoutRule");
+function resolveFieldValue(player, field) {
+    if (field === 'mainInstrument')
+        return player.mainInstrument;
+    if (field === 'isGuest')
+        return player.isGuest;
+    if (field.startsWith('custom.')) {
+        const key = field.slice('custom.'.length);
+        const v = player.customFields[key];
+        return v === undefined ? null : v;
+    }
+    return null;
+}
+function evaluateCondition(player, condition) {
+    const fieldValue = resolveFieldValue(player, condition.field);
+    const target = condition.value;
+    switch (condition.operator) {
+        case payoutRule_1.PayoutRuleConditionOperator.Eq:
+            return fieldValue === target;
+        case payoutRule_1.PayoutRuleConditionOperator.Neq:
+            return fieldValue !== target;
+        case payoutRule_1.PayoutRuleConditionOperator.Gt:
+            return (typeof fieldValue === 'number' && typeof target === 'number' && fieldValue > target);
+        case payoutRule_1.PayoutRuleConditionOperator.Gte:
+            return (typeof fieldValue === 'number' && typeof target === 'number' && fieldValue >= target);
+        case payoutRule_1.PayoutRuleConditionOperator.Lt:
+            return (typeof fieldValue === 'number' && typeof target === 'number' && fieldValue < target);
+        case payoutRule_1.PayoutRuleConditionOperator.Lte:
+            return (typeof fieldValue === 'number' && typeof target === 'number' && fieldValue <= target);
+        case payoutRule_1.PayoutRuleConditionOperator.In:
+            return Array.isArray(target) && target.includes(fieldValue);
+        case payoutRule_1.PayoutRuleConditionOperator.Nin:
+            return Array.isArray(target) && !target.includes(fieldValue);
+        default:
+            return false;
+    }
+}
+function ruleMatchesPlayer(player, rule) {
+    if (!rule.conditions || rule.conditions.length === 0)
+        return true;
+    return rule.conditions.every((c) => evaluateCondition(player, c));
+}
+const PLAYER_EFFECT_TYPES = new Set([
+    payoutRule_1.PayoutRuleType.PlayerExclude,
+    payoutRule_1.PayoutRuleType.PlayerFixed,
+    payoutRule_1.PayoutRuleType.PlayerMultiplier,
+    payoutRule_1.PayoutRuleType.PlayerBonus,
+]);
+function round2(n) {
+    return Math.round(n * 100) / 100;
+}
+/**
+ * Pure function that evaluates the event payout rules against a single player.
+ *
+ * Apply order (after sorting rules by `order` asc):
+ *  1. `PlayerExclude` — short-circuits with `excluded: true`.
+ *  2. `PlayerFixed` — replaces the running amount.
+ *  3. `PlayerMultiplier` — multiplies the running amount.
+ *  4. `PlayerBonus` — adds a fixed amount.
+ *
+ * When `baseAmount === null` (importByMember "to be determined"):
+ *  - Rules that depend on the base (Fixed, Multiplier) keep `runningAmount: null`
+ *    in their `AppliedRuleEntry` and the result `finalAmount` stays `null`.
+ *  - `PlayerBonus` is recorded with its `delta` but `runningAmount` stays `null`
+ *    until the base is set.
+ *
+ * Non-player rules (`EntityShare`, `DefaultExpense`) are ignored here — they
+ * affect the global budget, not the per-player amount.
+ */
+function evaluateRulesForPlayer(player, rules, baseAmount) {
+    const playerRules = rules
+        .filter((r) => PLAYER_EFFECT_TYPES.has(r.effect.type))
+        .slice()
+        .sort((a, b) => a.order - b.order);
+    const appliedRules = [];
+    let running = baseAmount;
+    let excluded = false;
+    let excludedByRuleId = null;
+    for (const rule of playerRules) {
+        if (!ruleMatchesPlayer(player, rule))
+            continue;
+        if (rule.effect.type === payoutRule_1.PayoutRuleType.PlayerExclude) {
+            excluded = true;
+            excludedByRuleId = rule.id;
+            appliedRules.push({
+                ruleId: rule.id,
+                name: rule.name,
+                effect: rule.effect,
+                delta: null,
+                runningAmount: null,
+            });
+            break;
+        }
+        if (rule.effect.type === payoutRule_1.PayoutRuleType.PlayerFixed) {
+            const next = round2(rule.effect.data.amount);
+            const delta = running === null ? null : round2(next - running);
+            appliedRules.push({
+                ruleId: rule.id,
+                name: rule.name,
+                effect: rule.effect,
+                delta,
+                runningAmount: next,
+            });
+            running = next;
+            continue;
+        }
+        if (rule.effect.type === payoutRule_1.PayoutRuleType.PlayerMultiplier) {
+            if (running === null) {
+                appliedRules.push({
+                    ruleId: rule.id,
+                    name: rule.name,
+                    effect: rule.effect,
+                    delta: null,
+                    runningAmount: null,
+                });
+                continue;
+            }
+            const next = round2(running * rule.effect.data.multiplier);
+            appliedRules.push({
+                ruleId: rule.id,
+                name: rule.name,
+                effect: rule.effect,
+                delta: round2(next - running),
+                runningAmount: next,
+            });
+            running = next;
+            continue;
+        }
+        if (rule.effect.type === payoutRule_1.PayoutRuleType.PlayerBonus) {
+            const delta = round2(rule.effect.data.amount);
+            if (running === null) {
+                appliedRules.push({
+                    ruleId: rule.id,
+                    name: rule.name,
+                    effect: rule.effect,
+                    delta,
+                    runningAmount: null,
+                });
+                continue;
+            }
+            const next = round2(running + delta);
+            appliedRules.push({
+                ruleId: rule.id,
+                name: rule.name,
+                effect: rule.effect,
+                delta,
+                runningAmount: next,
+            });
+            running = next;
+            continue;
+        }
+    }
+    return {
+        excluded,
+        excludedByRuleId,
+        baseAmount,
+        finalAmount: excluded ? null : running,
+        appliedRules,
+    };
+}

package/helpers/plans.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planGroupTiers = exports.pricesPerPlan = exports.membersPerPlan = exports.PlanPeriod = exports.PlansGroup = void 0;
+var PlansGroup;
+(function (PlansGroup) {
+    PlansGroup["Piano"] = "piano";
+    PlansGroup["MezzoPiano"] = "mezzopiano";
+    PlansGroup["MezzoForte"] = "mezzoforte";
+    PlansGroup["Forte"] = "forte";
+    PlansGroup["Fortissimo"] = "fortissimo";
+    PlansGroup["Tutti"] = "tutti";
+})(PlansGroup || (exports.PlansGroup = PlansGroup = {}));
+var PlanPeriod;
+(function (PlanPeriod) {
+    PlanPeriod["Yearly"] = "yearly";
+    PlanPeriod["Monthly"] = "monthly";
+})(PlanPeriod || (exports.PlanPeriod = PlanPeriod = {}));
+exports.membersPerPlan = {
+    [PlansGroup.Piano]: 20,
+    [PlansGroup.MezzoPiano]: 40,
+    [PlansGroup.MezzoForte]: 60,
+    [PlansGroup.Forte]: 80,
+    [PlansGroup.Fortissimo]: 100,
+    [PlansGroup.Tutti]: 1000,
+};
+exports.pricesPerPlan = {
+    [PlanPeriod.Monthly]: {
+        [PlansGroup.Piano]: 0,
+        [PlansGroup.MezzoPiano]: 9.9,
+        [PlansGroup.MezzoForte]: 14.9,
+        [PlansGroup.Forte]: 19.9,
+        [PlansGroup.Fortissimo]: 24.9,
+        [PlansGroup.Tutti]: 29.9,
+    },
+    [PlanPeriod.Yearly]: {
+        [PlansGroup.Piano]: 0,
+        [PlansGroup.MezzoPiano]: 99,
+        [PlansGroup.MezzoForte]: 149,
+        [PlansGroup.Forte]: 199,
+        [PlansGroup.Fortissimo]: 249,
+        [PlansGroup.Tutti]: 299,
+    },
+};
+exports.planGroupTiers = [
+    {
+        min: 0,
+        max: exports.membersPerPlan[PlansGroup.Piano],
+        monthly: exports.pricesPerPlan[PlanPeriod.Monthly][PlansGroup.Piano],
+        yearly: exports.pricesPerPlan[PlanPeriod.Yearly][PlansGroup.Piano],
+        label: '0-20',
+        name: 'Piano',
+        id: PlansGroup.Piano,
+    },
+    {
+        min: 21,
+        max: exports.membersPerPlan[PlansGroup.MezzoPiano],
+        monthly: exports.pricesPerPlan[PlanPeriod.Monthly][PlansGroup.MezzoPiano],
+        yearly: exports.pricesPerPlan[PlanPeriod.Yearly][PlansGroup.MezzoPiano],
+        label: '21-40',
+        name: 'Mezzopiano',
+        id: PlansGroup.MezzoPiano,
+    },
+    {
+        min: 41,
+        max: exports.membersPerPlan[PlansGroup.MezzoForte],
+        monthly: exports.pricesPerPlan[PlanPeriod.Monthly][PlansGroup.MezzoForte],
+        yearly: exports.pricesPerPlan[PlanPeriod.Yearly][PlansGroup.MezzoForte],
+        label: '41-60',
+        name: 'Mezzoforte',
+        id: PlansGroup.MezzoForte,
+    },
+    {
+        min: 61,
+        max: exports.membersPerPlan[PlansGroup.Forte],
+        monthly: exports.pricesPerPlan[PlanPeriod.Monthly][PlansGroup.Forte],
+        yearly: exports.pricesPerPlan[PlanPeriod.Yearly][PlansGroup.Forte],
+        label: '61-80',
+        name: 'Forte',
+        id: PlansGroup.Forte,
+    },
+    {
+        min: 81,
+        max: exports.membersPerPlan[PlansGroup.Fortissimo],
+        monthly: exports.pricesPerPlan[PlanPeriod.Monthly][PlansGroup.Fortissimo],
+        yearly: exports.pricesPerPlan[PlanPeriod.Yearly][PlansGroup.Fortissimo],
+        label: '81-100',
+        name: 'Fortissimo',
+        id: PlansGroup.Fortissimo,
+    },
+    {
+        min: 101,
+        max: Infinity,
+        monthly: exports.pricesPerPlan[PlanPeriod.Monthly][PlansGroup.Tutti],
+        yearly: exports.pricesPerPlan[PlanPeriod.Yearly][PlansGroup.Tutti],
+        label: '+100',
+        name: 'Tutti',
+        id: PlansGroup.Tutti,
+    },
+];

package/helpers/rates.d.ts

@@ -0,0 +1,13 @@
+import { VoteValue } from '../models/Group/Repertory/types';
+export declare const rateSteps: {
+    id: 'love' | 'like' | 'neutral' | 'dislike';
+    emoji: string;
+    value: VoteValue;
+    range: [number, number];
+}[];
+export declare const getStepRating: (rating: number) => {
+    id: "love" | "like" | "neutral" | "dislike";
+    emoji: string;
+    value: VoteValue;
+    range: [number, number];
+} | undefined;