@go-avro/avro-js 0.0.45 → 0.0.46

package/dist/types/api/Job.d.ts

@@ -35,6 +35,21 @@ export declare class Job {
     getOverdueLabel: () => string;
     getStatus(): "PENDING_CUSTOMER" | "PENDING_COMPANY" | "ACTIVE" | "ARCHIVED" | "DRAFT" | "PENDING_PAYMENT" | "PENDING_ACTIVATION";
     getStatusLabel(): "Active" | "Draft" | "Archived" | "Pending Activation" | "Customer Approval" | "Company Approval" | "Awaiting Payment";
+    /**
+     * Returns the sum of `service` (in seconds) for the tasks attached to a
+     * given routeJob. Use this to compute predicted completion time:
+     * `routeJob.getPredictedArrival() + job.getServiceDuration(routeJob)`.
+     */
+    getServiceDuration: (routeJob: RouteJob) => number;
+    /**
+     * Returns the most relevant event for the job in its current state:
+     * the active `current_event` if one exists, otherwise the
+     * `last_completed_event`. Falls back to `null`.
+     *
+     * Most callers historically used `last_completed_event ?? current_event`
+     * which inverted the precedence — prefer the live event over a stale one.
+     */
+    getRouteEvent: () => _Event | null;
     portionDone: (route: Route) => number;
     isDone: (route: Route) => boolean;
 }

package/dist/types/api/Job.js

@@ -21,6 +21,27 @@ export class Job {
             }, activeTasks[0]);
             return mostOverdueTask.getOverdueLabel?.() ?? 'N/A';
         };
+        /**
+         * Returns the sum of `service` (in seconds) for the tasks attached to a
+         * given routeJob. Use this to compute predicted completion time:
+         * `routeJob.getPredictedArrival() + job.getServiceDuration(routeJob)`.
+         */
+        this.getServiceDuration = (routeJob) => {
+            return routeJob.tasks
+                .map((tid) => this.tasks.find((t) => t.id === tid)?.service ?? 0)
+                .reduce((a, b) => a + b, 0);
+        };
+        /**
+         * Returns the most relevant event for the job in its current state:
+         * the active `current_event` if one exists, otherwise the
+         * `last_completed_event`. Falls back to `null`.
+         *
+         * Most callers historically used `last_completed_event ?? current_event`
+         * which inverted the precedence — prefer the live event over a stale one.
+         */
+        this.getRouteEvent = () => {
+            return this.current_event ?? this.last_completed_event ?? null;
+        };
         this.portionDone = (route) => {
             if (!this.tasks || this.tasks.length === 0) {
                 return 0;

package/dist/types/api/Route.d.ts

@@ -1,4 +1,5 @@
 import { RouteJob } from '../../types/api/RouteJob';
+import type { Job } from '../../types/api/Job';
 export declare const FrequencyType: {
     readonly ONCE: "ONCE";
     readonly DAILY: "DAILY";
@@ -33,4 +34,16 @@ export declare class Route {
     constructor(init?: Partial<Route>);
     getNextOccurrences: (count?: number) => (Date | null)[];
     getNextOccurrence: (after?: Date) => Date | null;
+    /**
+     * Computes how far ahead/behind schedule the route is, in seconds, based on
+     * stops that have already been completed. Positive = behind schedule,
+     * negative = ahead of schedule.
+     *
+     * The offset is taken from the most recently completed stop (largest
+     * `time_ended`), not the last stop in route order. This is what consumers
+     * want: "given the latest completed work, how off-schedule are we?".
+     *
+     * Returns `null` if no stop in this route has a usable completion event.
+     */
+    getScheduleOffset: (jobs: Job[]) => number | null;
 }

package/dist/types/api/Route.js

@@ -43,6 +43,38 @@ export class Route {
             }
             return next_occurrence;
         };
+        /**
+         * Computes how far ahead/behind schedule the route is, in seconds, based on
+         * stops that have already been completed. Positive = behind schedule,
+         * negative = ahead of schedule.
+         *
+         * The offset is taken from the most recently completed stop (largest
+         * `time_ended`), not the last stop in route order. This is what consumers
+         * want: "given the latest completed work, how off-schedule are we?".
+         *
+         * Returns `null` if no stop in this route has a usable completion event.
+         */
+        this.getScheduleOffset = (jobs) => {
+            let latestEnd = -Infinity;
+            let offset = null;
+            for (const rj of this.jobs) {
+                const job = jobs.find((j) => j.id === rj.job_id);
+                if (!job || !job.isDone(this))
+                    continue;
+                // Offset semantics specifically want a *completed* event, not an
+                // in-progress one. Use last_completed_event directly rather than
+                // getRouteEvent() (which prefers current_event for display).
+                const actualEnd = job.last_completed_event?.time_ended;
+                if (typeof actualEnd !== 'number' || actualEnd <= 0)
+                    continue;
+                if (actualEnd <= latestEnd)
+                    continue;
+                const predictedCompletion = rj.getPredictedArrival() + job.getServiceDuration(rj);
+                latestEnd = actualEnd;
+                offset = actualEnd - predictedCompletion;
+            }
+            return offset;
+        };
         Object.assign(this, init);
         if (init?.jobs) {
             this.jobs = init.jobs.map((j) => new RouteJob(j));

package/dist/types/api/RouteJob.d.ts

@@ -12,4 +12,11 @@ declare module '../../types/api/RouteJob' {
 }
 export declare class RouteJob {
     constructor(init?: Partial<RouteJob>);
+    /**
+     * Returns the arrival time the UI should show for this stop:
+     * `scheduled_arrival_time` if set (>= 0), otherwise the optimizer's
+     * `estimated_arrival_time`. The sentinel value -1 means "no manual
+     * schedule, fall back to the optimizer estimate".
+     */
+    getPredictedArrival: () => number;
 }

package/dist/types/api/RouteJob.js

@@ -1,5 +1,16 @@
 export class RouteJob {
     constructor(init) {
+        /**
+         * Returns the arrival time the UI should show for this stop:
+         * `scheduled_arrival_time` if set (>= 0), otherwise the optimizer's
+         * `estimated_arrival_time`. The sentinel value -1 means "no manual
+         * schedule, fall back to the optimizer estimate".
+         */
+        this.getPredictedArrival = () => {
+            return this.scheduled_arrival_time === -1
+                ? this.estimated_arrival_time
+                : this.scheduled_arrival_time;
+        };
         Object.assign(this, init);
     }
 }

package/dist/types/api/Task.js

@@ -102,12 +102,15 @@ export class Task {
             if (!this.status || this.status !== TaskStatus.ACTIVE) {
                 return true;
             }
-            if (this.frequency > 0) {
-                return (this.last_completed_event?.time_ended ?? 0) > route.start_time;
-            }
-            else {
-                return this.last_completed_event?.time_ended ? true : false;
-            }
+            // Cutoff: midnight (local time) of the day route.start_time falls on.
+            // Counts work completed at any point during the route's day (including
+            // an early-start autostart that finishes a few minutes before
+            // route.start_time) while still rejecting stale events from previous
+            // occurrences. Applies to both recurring and one-shot tasks.
+            const routeDay = new Date(route.start_time * 1000);
+            routeDay.setHours(0, 0, 0, 0);
+            const cutoff = Math.floor(routeDay.getTime() / 1000);
+            return (this.last_completed_event?.time_ended ?? 0) >= cutoff;
         };
         Object.assign(this, init);
         if (init?.prepayments) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-avro/avro-js",
-  "version": "0.0.45",
+  "version": "0.0.46",
   "description": "JS client for Avro backend integration.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",