@fabriktor/fx 0.0.150 → 0.0.152

package/dist/src/routes/availability.d.ts

@@ -46,6 +46,9 @@ export declare function loadAvailabilityRequestContext(readers: AvailabilityRead
 }, actor: RoutesActor, data: ChatData): Promise<AvailabilityFormContext>;
 export declare function availabilitySubmission(reference: AvailabilityReference, request_id: string, ids: readonly string[]): ChatData;
 export declare function loadAvailabilityContext(readers: AvailabilityReaders, actor: RoutesActor, reference: AvailabilityReference, { request, signal }?: AvailabilityContextOptions): Promise<AvailabilityContext>;
+type AvailabilityWindow = Pick<InClientAvailability, "from" | "to" | "timezone">;
+export declare function isValidAvailabilityWindow(window: AvailabilityWindow): boolean;
+export declare function availabilityWindowConflicts(inputs: readonly AvailabilityWindow[]): number[];
 export declare function validateAvailabilityWindows(inputs: readonly InClientAvailability[], context: AvailabilityContext, minimum?: number): void;
 export declare function loadAvailabilitySelection(readers: AvailabilityReaders & {
     routes: Pick<RoutesOperator, "findOneClientAvailability">;
@@ -53,3 +56,4 @@ export declare function loadAvailabilitySelection(readers: AvailabilityReaders &
     context: AvailabilityContext;
     windows: ClientAvailability[];
 }>;
+export {};

package/dist/src/routes/availability.js

@@ -1,7 +1,7 @@
 import { UserTypeClient, UserTypeEmployer, } from "@fabriktor/schema";
 import { isFabriktorUser } from "../users/users.js";
 import { addressTimezone } from "../core/address.js";
-import { hoursPerDay, minutesOfDay, minutesPerHour, sameCalendarDay, } from "../core/date.js";
+import { hoursPerDay, isValidInputDate, minutesOfDay, minutesPerHour, sameCalendarDay, } from "../core/date.js";
 import { errValidation } from "../core/err.js";
 import { normalizeIDs, resolvedID } from "../core/id.js";
 import { newChatData } from "../chat/data.js";
@@ -46,7 +46,9 @@ const msgAvailabilityAccess = "This availability does not match the client and e
 const msgAvailabilityTimezone = "The location needs a valid saved address timezone.";
 const msgAvailabilityTimezoneChanged = "The location timezone has changed. Ask the sender to send a new form.";
 const msgAvailabilityHours = "The employer's working hours must form a valid same-day window.";
-const msgAvailabilityWindows = "Provide enough distinct, non-overlapping availability windows and respect the hours supplied with the request.";
+const msgAvailabilityMinimumWindows = "Choose at least {count} possible visit times.";
+const msgAvailabilityWindows = "Some visit times overlap. Choose another day or change their hours.";
+const msgAvailabilityOutsideHours = "Choose visit times within the working hours shown.";
 const msgAvailabilityClient = "Visit times can only be requested from clients with a Fabriktor account. Arrange external contacts’ visit times directly.";
 const msgAvailabilityData = "The availability request is invalid.";
 export function availabilityReference(data) {
@@ -178,26 +180,54 @@ export async function loadAvailabilityContext(readers, actor, reference, { reque
         timezone,
     };
 }
+export function isValidAvailabilityWindow(window) {
+    return (isValidInputDate(window.from) &&
+        isValidInputDate(window.to) &&
+        window.from.tz === window.timezone &&
+        window.to.tz === window.timezone &&
+        sameCalendarDay(window.from, window.to) &&
+        minutesOfDay(window.from) < minutesOfDay(window.to));
+}
+// Return every affected row, including duplicates. Incomplete rows are handled
+// by the inputs' required/date/time rules, not by the overlap rule.
+export function availabilityWindowConflicts(inputs) {
+    const conflicts = new Set();
+    inputs.forEach((input, index) => {
+        if (!isValidAvailabilityWindow(input))
+            return;
+        inputs.slice(0, index).forEach((other, previous) => {
+            if (isValidAvailabilityWindow(other) &&
+                input.timezone === other.timezone &&
+                sameCalendarDay(input.from, other.from) &&
+                minutesOfDay(input.from) < minutesOfDay(other.to) &&
+                minutesOfDay(input.to) > minutesOfDay(other.from)) {
+                conflicts.add(previous);
+                conflicts.add(index);
+            }
+        });
+    });
+    return inputs.flatMap((_, index) => (conflicts.has(index) ? [index] : []));
+}
 export function validateAvailabilityWindows(inputs, context, minimum = clientAvailabilityMinimumWindows) {
     if (inputs.length < minimum)
-        throw errValidation({ msg: msgAvailabilityWindows });
-    for (const [index, input] of inputs.entries()) {
+        throw errValidation({
+            msg: msgAvailabilityMinimumWindows.replace("{count}", String(minimum)),
+        });
+    for (const input of inputs) {
         validateClientAvailabilityInput(input);
         if (input.employer_id !== context.employer.id ||
             input.location_id !== context.location.id ||
-            input.timezone !== context.timezone ||
-            (context.working_hours &&
-                (minutesOfDay(input.from) <
-                    context.working_hours.work_day_start_hour * minutesPerHour ||
-                    minutesOfDay(input.to) >
-                        context.working_hours.work_day_end_hour * minutesPerHour)) ||
-            inputs
-                .slice(0, index)
-                .some((other) => sameCalendarDay(input.from, other.from) &&
-                minutesOfDay(input.from) < minutesOfDay(other.to) &&
-                minutesOfDay(input.to) > minutesOfDay(other.from)))
-            throw errValidation({ msg: msgAvailabilityWindows });
+            input.timezone !== context.timezone)
+            throw errValidation({ msg: msgAvailabilityAccess });
+        if (context.working_hours &&
+            (minutesOfDay(input.from) <
+                context.working_hours.work_day_start_hour * minutesPerHour ||
+                minutesOfDay(input.to) >
+                    context.working_hours.work_day_end_hour * minutesPerHour))
+            throw errValidation({ msg: msgAvailabilityOutsideHours });
     }
+    if (availabilityWindowConflicts(inputs).length)
+        throw errValidation({ msg: msgAvailabilityWindows });
 }
 // A chat response contains references, never authority or an appointment confirmation.
 // Reload each chosen record before preparing the response, including after a resumed batch.

package/dist/src/routes/departure.d.ts

@@ -29,6 +29,10 @@ export declare const RoutePlanningBlock: {
     readonly DepartureChanged: "route_departure_changed";
     readonly DestinationTimezone: "route_destination_timezone";
     readonly DestinationChanged: "route_destination_changed";
+    readonly DestinationOwner: "route_destination_owner";
+    readonly DestinationArchived: "route_destination_archived";
+    readonly DestinationAddress: "route_destination_address";
+    readonly DestinationClient: "route_destination_client";
 };
 export declare function companyRouteDeparture(user: User): RouteDeparture;
 export declare function warehouseRouteDeparture(warehouse: Warehouse, owner_id: string): RouteDeparture;

package/dist/src/routes/departure.js

@@ -12,6 +12,10 @@ export const RoutePlanningBlock = {
     DepartureChanged: "route_departure_changed",
     DestinationTimezone: "route_destination_timezone",
     DestinationChanged: "route_destination_changed",
+    DestinationOwner: "route_destination_owner",
+    DestinationArchived: "route_destination_archived",
+    DestinationAddress: "route_destination_address",
+    DestinationClient: "route_destination_client",
 };
 export function companyRouteDeparture(user) {
     if (user.account_identity !== UserTypeEmployer ||
@@ -57,11 +61,14 @@ export async function loadRouteDeparture(readers, owner_id, reference, signal) {
     throw new PreActionBlocked(RoutePlanningBlock.Departure);
 }
 export function validateRoutePlanLocation(location, owner_id, timezone) {
-    if (location.owner_id !== owner_id ||
-        location.is_archived ||
-        !location.place_id.trim() ||
-        !resolvedID(location.client_id))
-        throw new PreActionBlocked(RoutePlanningBlock.DestinationChanged);
+    if (location.owner_id !== owner_id)
+        throw new PreActionBlocked(RoutePlanningBlock.DestinationOwner);
+    if (location.is_archived)
+        throw new PreActionBlocked(RoutePlanningBlock.DestinationArchived);
+    if (!location.place_id?.trim())
+        throw new PreActionBlocked(RoutePlanningBlock.DestinationAddress);
+    if (!resolvedID(location.client_id))
+        throw new PreActionBlocked(RoutePlanningBlock.DestinationClient);
     if (addressTimezone(location) !== timezone)
         throw new PreActionBlocked(RoutePlanningBlock.DestinationTimezone);
 }

package/dist/src/routes/planning.d.ts

@@ -30,5 +30,12 @@ export type RouteAvailabilityWindow = {
     start: number;
     end: number;
 };
+export declare function routeAvailabilityMatch(input: Pick<InRoute, "from" | "to" | "timezone">, availability: ClientAvailability): RouteAvailabilityWindow | undefined;
+export type RouteAvailabilityOverview = {
+    saved: ClientAvailability[];
+    matching: RouteAvailabilityWindow[];
+    on_day: number;
+};
+export declare function routeAvailabilityOverview(input: Pick<InRoute, "from" | "to" | "timezone">, availability: RPRoutesAvailability, location_id: string, client_id: string): RouteAvailabilityOverview;
 export declare function routeAvailabilityWindows(input: Pick<InRoute, "from" | "to" | "timezone">, availability: RPRoutesAvailability, location_id: string, client_id: string): RouteAvailabilityWindow[];
 export {};

package/dist/src/routes/planning.js

@@ -1,8 +1,9 @@
-import { isValidInputDate, minutesOfDay, sameCalendarDay, } from "../core/date.js";
+import { minutesOfDay, sameCalendarDay } from "../core/date.js";
 import { errValidation } from "../core/err.js";
 import { normalizeIDs } from "../core/id.js";
 import { routeInput, validateRouteTimeWindow } from "./validation.js";
 import { validateRoutePlanLocation } from "./departure.js";
+import { isValidAvailabilityWindow } from "./availability.js";
 import { PreActionBlocked } from "../core/pre-action.js";
 const routePreparationBlocked = "route_preparation";
 const msgPlanningEmployees = "Choose available employees who are not already in another vehicle.";
@@ -71,25 +72,37 @@ export function validateRouteEmployees(ids, allowed, occupied = []) {
             msg: msgPlanningEmployees,
         });
 }
-// Suggestions are child data in an availability response. Intersect the client's
-// window with the route window; never widen the hours offered by either party.
-export function routeAvailabilityWindows(input, availability, location_id, client_id) {
+// Intersect the client's window with the route hours; never widen either.
+export function routeAvailabilityMatch(input, availability) {
+    if (!isValidAvailabilityWindow(availability) ||
+        availability.timezone !== input.timezone ||
+        !sameCalendarDay(availability.from, input.from))
+        return;
+    const start = Math.max(minutesOfDay(availability.from), minutesOfDay(input.from));
+    const end = Math.min(minutesOfDay(availability.to), minutesOfDay(input.to));
+    return start < end ? { availability, start, end } : undefined;
+}
+// These are child windows returned by get_availability, not a filtered parent
+// query. Keep other days visible and preserve the backend's order.
+export function routeAvailabilityOverview(input, availability, location_id, client_id) {
     validateRouteTimeWindow(input);
-    return availability.client_availabilities
+    const saved = availability.client_availabilities
         .flatMap((group) => group.location_id === location_id ? group.availabilities : [])
-        .flatMap((window) => {
-        if (window.owner_id !== client_id ||
-            window.location_id !== location_id ||
-            window.timezone !== input.timezone ||
-            window.from.tz !== input.timezone ||
-            window.to.tz !== input.timezone ||
-            !isValidInputDate(window.from) ||
-            !isValidInputDate(window.to) ||
-            !sameCalendarDay(window.from, input.from) ||
-            !sameCalendarDay(window.to, input.to))
-            return [];
-        const start = Math.max(minutesOfDay(window.from), minutesOfDay(input.from));
-        const end = Math.min(minutesOfDay(window.to), minutesOfDay(input.to));
-        return start < end ? [{ availability: window, start, end }] : [];
-    });
+        .filter((window) => window.owner_id === client_id &&
+        window.location_id === location_id &&
+        window.timezone === input.timezone &&
+        isValidAvailabilityWindow(window));
+    return {
+        saved,
+        matching: saved.flatMap((window) => {
+            const match = routeAvailabilityMatch(input, window);
+            return match ? [match] : [];
+        }),
+        on_day: saved.filter((window) => sameCalendarDay(window.from, input.from))
+            .length,
+    };
+}
+export function routeAvailabilityWindows(input, availability, location_id, client_id) {
+    return routeAvailabilityOverview(input, availability, location_id, client_id)
+        .matching;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.150",
+  "version": "0.0.152",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {