@fin.cx/compatibility 5.0.1 → 5.2.0

package/ts/extf/index.ts

@@ -518,8 +518,9 @@ export const correctionOf = (
 export interface ICorrectionBuchungsstapelOptions {
   /**
    * The bookings of the period as they were handed over, as a whole: the bookings of its Buchungsstapel as stored
-   * (`IBuchungsstapelFile.bookings`), or after a correction the period's bookings as that correction left them
-   * (`bookingsAfter`). Each must state its cost centres: one stored before 4.1 does not, and is refused
+   * (`IBuchungsstapelFile.bookings`), after a correction the period's bookings as that correction left them
+   * (`bookingsAfter`), and after more than one Stapel the bookings that stand after all of them (`bookingsHeldOf`).
+   * Each must state its cost centres: one stored before 4.1 does not, and is refused
    * (`handed_over_cost_centres_unknown`); pass the rows sent for it. Bookings stored by any version, before or after
    * writing, are compared as a file states them (`comparableOf`), so a reference the writer changed is no change.
    */
@@ -529,7 +530,8 @@ export interface ICorrectionBuchungsstapelOptions {
    * `readExtfBuchungsstapel(bytes).rows`, skr 7.0.1 and later) or the rows given to the writer
    * (`IBuchungsstapelFile.rows`), taken as the file states them (`bookingsAsWritten`). What DATEV received, cost
    * centres (fields 37 and 38) included, so a reversal mirrors it exactly. For a Stapel whose bookings were stored
-   * before 4.1, which record no cost centres.
+   * before 4.1, which record no cost centres. The rows of one Stapel: after more than one, pass `handedOver` as
+   * `bookingsHeldOf` of the bookings of each file read back.
    */
   handedOverRows?: readonly IDatevBuchungsstapelRow[];
   /** the period's drafts as they stand now */
@@ -583,3 +585,69 @@ export const writeCorrectionBuchungsstapel = (optionsArg: ICorrectionBuchungssta
   // the rows booked anew as the correction file states them, after the reversals
   return { ...file, reversed, added, bookingsAfter: [...kept, ...file.bookings.slice(reversed.length)] };
 };
+
+/**
+ * The bookings of a period as DATEV holds them after its Stapel, handed over in the order given: the period's
+ * Buchungsstapel, the additional Stapel after it and its correction Stapel (`writeCorrectionBuchungsstapel`), each as
+ * the bookings it stated (`IBuchungsstapelFile.bookings` as stored, or `bookingsOfRows` of its file read back), in
+ * their order. An ordinary booking stands. A general reversal (field 118 "Generalumkehr") takes back one booking that
+ * stands before it, in an earlier Stapel or earlier in its own, and does not stand itself: the booking it mirrors says
+ * what it says (`differingBookingCount`'s fields, the reversal apart), compared as a file states them
+ * (`comparableOf`), so wording and document link do not count. A booking on the cost centres the reversal states is
+ * taken first, then one stored before 4.1, which records none; of several, the last, as a correction reverses the
+ * last of several bookings it no longer holds. A reversal of no booking that stands before it is refused
+ * (`invalid_bookings`, naming its Stapel and place): DATEV would hold a counter-booking of nothing. The bookings that
+ * stand, as they were given and in their order: what the next correction is compared against (`handedOver`), and
+ * after one correction its `bookingsAfter`. A booking a Buchungsstapel cannot hold is refused (`invalid_bookings`).
+ */
+export const bookingsHeldOf = (stapelArg: readonly (readonly IExportBooking[])[]): IExportBooking[] => {
+  const given = stapelArg.flat();
+  const comparable = comparableOf(given);
+  // where each booking stands: its Stapel and its place in it, for a refusal
+  const places = stapelArg.flatMap((stapelBookingsArg, stapelIndexArg) => stapelBookingsArg.map((_bookingArg, indexArg) => ({ stapel: stapelIndexArg, index: indexArg })));
+  const takenBack = given.map(() => false);
+  // the bookings that stand, by what they say: recorded ones on every key field and on the rest, unrecorded ones on the rest
+  const recordedByFullKey = new Map<string, number[]>();
+  const recordedByBaseKey = new Map<string, number[]>();
+  const unrecordedByBaseKey = new Map<string, number[]>();
+  const stand = (queuesArg: Map<string, number[]>, keyArg: string, indexArg: number): void => {
+    const queue = queuesArg.get(keyArg);
+    if (queue) {
+      queue.push(indexArg);
+    } else {
+      queuesArg.set(keyArg, [indexArg]);
+    }
+  };
+  // the last booking of a queue that still stands; a booking taken back through another queue is passed over for good
+  const lastStanding = (queuesArg: Map<string, number[]>, keyArg: string): number | undefined => {
+    const queue = queuesArg.get(keyArg);
+    while (queue && queue.length > 0 && takenBack[queue[queue.length - 1]]) {
+      queue.pop();
+    }
+    return queue?.[queue.length - 1];
+  };
+  comparable.forEach((bookingArg, indexArg) => {
+    if (!bookingArg.generalumkehr) {
+      if (recordsCostCentres(bookingArg)) {
+        stand(recordedByFullKey, fullKeyOf(bookingArg), indexArg);
+        stand(recordedByBaseKey, baseKeyOf(bookingArg), indexArg);
+      } else {
+        stand(unrecordedByBaseKey, baseKeyOf(bookingArg), indexArg);
+      }
+      return;
+    }
+    // the booking the reversal mirrors says what it says
+    const { generalumkehr: _generalumkehr, ...mirrored } = bookingArg;
+    const baseKey = baseKeyOf(mirrored);
+    const unrecorded = lastStanding(unrecordedByBaseKey, baseKey);
+    const taken = recordsCostCentres(mirrored)
+      ? lastStanding(recordedByFullKey, fullKeyOf(mirrored)) ?? unrecorded
+      : Math.max(lastStanding(recordedByBaseKey, baseKey) ?? -1, unrecorded ?? -1);
+    if (taken === undefined || taken < 0) {
+      const { stapel, index } = places[indexArg];
+      throw new CompatibilityError('invalid_bookings', `Stapel ${stapel + 1}, ${bookingNameOf(given[indexArg], index)} is a general reversal of no booking handed over before it`);
+    }
+    takenBack[taken] = true;
+  });
+  return given.filter((_bookingArg, indexArg) => !comparable[indexArg].generalumkehr && !takenBack[indexArg]);
+};

package/ts/index.ts

@@ -2,3 +2,4 @@ export * from './error.js';
 export * from './encoding/index.js';
 export * as extf from './extf/index.js';
 export * as belegbilder from './belegbilder/index.js';
+export * as buchungsliste from './buchungsliste/index.js';