@fleetbase/fleetops-engine 0.6.70 → 0.6.72

package/addon/utils/resource-descriptors/assets.js

@@ -1,68 +1,13 @@
 import { get } from '@ember/object';
 import { first, present, relation, photo, icon, badge, badges, fact, relatedFact, money, join, panelOpener } from './helpers';
+import { sharedDescriptors } from './shared';
 
 /**
  * Vehicles, trailers, equipment, parts, generic assets and warranties.
  */
 export default function buildAssetDescriptors(owner) {
     return [
-        {
-            key: 'vehicle',
-            labelKey: 'resource.vehicle',
-            icon: 'truck',
-            modelNames: ['vehicle'],
-            aliases: ['attachable-vehicle', 'maintenance-subject-vehicle'],
-            polymorphicTypes: ['fleet-ops:vehicle', 'Fleetbase\\FleetOps\\Models\\Vehicle'],
-            permission: 'fleet-ops view vehicle',
-            statusTones: {
-                available: 'text-green-500',
-                active: 'text-green-500',
-                in_service: 'text-green-500',
-                maintenance: 'text-yellow-500',
-                unavailable: 'text-gray-400',
-                inactive: 'text-gray-400',
-                out_of_service: 'text-red-500',
-            },
-            title: (vehicle) =>
-                first(vehicle, 'displayName', 'display_name', 'name', 'yearMakeModel', 'public_id') ?? join([get(vehicle, 'year'), get(vehicle, 'make'), get(vehicle, 'model')]),
-            identifier: (vehicle) => first(vehicle, 'plate_number', 'call_sign', 'vin', 'serial_number'),
-            image: (vehicle) => photo(vehicle, 'vehicle'),
-            online: (vehicle) => {
-                const online = get(vehicle, 'online');
-
-                return typeof online === 'boolean' ? online : undefined;
-            },
-            status: (vehicle) => first(vehicle, 'status'),
-            badges: (vehicle) => {
-                const driver = relation(owner, vehicle, 'driver');
-
-                return badges(
-                    badge('plate', 'id-card', first(vehicle, 'plate_number', 'call_sign', 'vehicle_number')),
-                    badge('driver', 'user', first(driver, 'name', 'displayName') ?? first(vehicle, 'driver_name'), {
-                        relatedType: 'driver',
-                        relatedId: driver?.id ?? get(vehicle, 'driver_uuid'),
-                    })
-                );
-            },
-            selectDetails: (vehicle) => [first(vehicle, 'plate_number', 'vin', 'serial_number', 'call_sign'), first(vehicle, 'driver_name')],
-            facts: (vehicle) => {
-                const driver = relation(owner, vehicle, 'driver');
-                const trailers = relation(owner, vehicle, 'trailers');
-                const trailer = trailers && typeof trailers.objectAt === 'function' ? trailers.objectAt(0) : Array.isArray(trailers) ? trailers[0] : null;
-                const extra = trailers?.length > 1 ? ` (+${trailers.length - 1})` : '';
-
-                return [
-                    fact('make-model', join([get(vehicle, 'year'), get(vehicle, 'make'), get(vehicle, 'model'), get(vehicle, 'trim')])),
-                    fact('plate', join([first(vehicle, 'plate_number'), first(vehicle, 'vin')], ' · ')),
-                    relatedFact('driver', driver, 'driver', first(vehicle, 'driver_name')),
-                    trailer ? { ...relatedFact('trailer', trailer, 'trailer', first(trailer, 'displayName', 'display_name', 'name')), suffix: extra } : fact('trailer', null),
-                    fact('odometer', present(get(vehicle, 'odometer')) ? join([get(vehicle, 'odometer'), get(vehicle, 'odometer_unit')]) : null),
-                    fact('status', first(vehicle, 'status'), { format: 'humanize' }),
-                ];
-            },
-            open: panelOpener(owner, 'vehicle-actions'),
-            components: { identity: 'cell/vehicle-identity' },
-        },
+        ...sharedDescriptors(owner, ['vehicle']),
         {
             key: 'trailer',
             labelKey: 'resource.trailer',

package/addon/utils/resource-descriptors/helpers.js

@@ -1,59 +1,29 @@
-import formatDate from '@fleetbase/ember-ui/utils/format-date';
-import { get } from '@ember/object';
-import { getPlaceholderImage, resolveResourceImage } from '../placeholder-images';
+import { first, relation } from '@fleetbase/fleetops-data/utils/resource-descriptors/helpers';
 
 /**
- * Small building blocks the FleetOps descriptors share. They are written
- * against attribute names, so an identity stub or an API payload renders
- * the same as an Ember Data record.
+ * The building blocks the FleetOps descriptors share. The ones a descriptor
+ * needs to read a record live in `@fleetbase/fleetops-data`, so the shared
+ * resources render the same in every extension; this module re-exports them
+ * and adds the openers that only make sense with the FleetOps engine's own
+ * services and routes.
  */
-
-export function present(value) {
-    return value !== undefined && value !== null && String(value).trim() !== '';
-}
-
-/** The first present value at any of the paths. */
-export function first(record, ...paths) {
-    if (!record) {
-        return null;
-    }
-
-    for (const path of paths) {
-        const value = get(record, path);
-
-        if (present(value)) {
-            return value;
-        }
-    }
-
-    return null;
-}
-
-/** A related record read through its reference, never a promise proxy. */
-export function relation(owner, record, name) {
-    const registry = owner?.lookup?.('service:resource-registry');
-
-    if (registry && typeof registry.relationValue === 'function') {
-        return registry.relationValue(record, name);
-    }
-
-    const value = record ? get(record, name) : null;
-
-    if (value && typeof value === 'object' && typeof value.then === 'function') {
-        return value.content ?? null;
-    }
-
-    return value ?? null;
-}
-
-/** A photo with the styled placeholder as fallback. */
-export function photo(record, type, path = 'photo_url') {
-    return { url: resolveResourceImage(get(record, path), type), fallback: getPlaceholderImage(type), shape: type === 'vehicle' || type === 'trailer' ? 'square' : 'round' };
-}
-
-export function icon(name, iconClass) {
-    return iconClass ? { icon: name, iconClass } : { icon: name };
-}
+export {
+    present,
+    first,
+    lookupService,
+    relation,
+    photo,
+    icon,
+    badge,
+    badges,
+    fact,
+    relatedFact,
+    dateLabel,
+    typeLabel,
+    money,
+    join,
+    polymorphicType,
+} from '@fleetbase/fleetops-data/utils/resource-descriptors/helpers';
 
 /** A coloured tile for records that carry their own colour (service areas, zones). */
 export function colourTile(record, name) {
@@ -62,75 +32,6 @@ export function colourTile(record, name) {
     return colour ? { icon: name, iconClass: 'resource-colour-tile', colour } : { icon: name };
 }
 
-export function badge(key, iconName, label, extra = {}) {
-    return present(label) ? { key, icon: iconName, label, ...extra } : null;
-}
-
-export function badges(...list) {
-    return list.filter(Boolean);
-}
-
-export function fact(label, value, extra = {}) {
-    return { labelKey: `resource-summary.facts.${label}`, value, ...extra };
-}
-
-/** A fact that renders as the related record's pill when the record is loaded. */
-export function relatedFact(label, related, relatedType, fallbackValue) {
-    return { labelKey: `resource-summary.facts.${label}`, related: related ?? null, relatedType, value: fallbackValue ?? null };
-}
-
-/**
- * A date the way the console writes one everywhere else (date-fns, not the
- * browser locale), or null for anything that is not a date.
- */
-export function dateLabel(value, pattern = 'dd MMM yyyy, HH:mm') {
-    if (!present(value)) {
-        return null;
-    }
-
-    const date = value instanceof Date ? value : new Date(value);
-
-    return Number.isNaN(date.getTime()) ? null : formatDate(date, pattern);
-}
-
-/**
- * A contact's type the way a person reads it: "customer-fleet-ops:contact"
- * and "customer" both become "Customer"; anything unreadable becomes null.
- */
-export function typeLabel(value) {
-    if (!present(value)) {
-        return null;
-    }
-
-    const head = String(value)
-        .split(':')[0]
-        .replace(/-fleet-ops$/, '')
-        .replace(/[-_]+/g, ' ')
-        .trim();
-
-    return head ? head.charAt(0).toUpperCase() + head.slice(1) : null;
-}
-
-export function money(amount, currency) {
-    if (!present(amount)) {
-        return null;
-    }
-
-    return present(currency) ? `${amount} ${currency}` : String(amount);
-}
-
-export function join(parts, separator = ' ') {
-    return parts.filter(present).join(separator) || null;
-}
-
-/** The resolved `*_type` for a polymorphic relation, from the record or a `_type` attribute. */
-export function polymorphicType(record, relationName, typeAttr) {
-    const related = record ? get(record, relationName) : null;
-    const modelName = related?.constructor?.modelName ?? related?.content?.constructor?.modelName;
-
-    return modelName ?? (typeAttr ? get(record, typeAttr) : null) ?? null;
-}
-
 /**
  * An opener that hands the record to an action service's context panel,
  * falling back to its route transition. Resolved lazily from the engine

package/addon/utils/resource-descriptors/operations.js

@@ -1,5 +1,6 @@
 import { get } from '@ember/object';
 import { first, present, relation, icon, colourTile, fact, relatedFact, money, join, panelOpener, routeOpener, polymorphicType, dateLabel } from './helpers';
+import { sharedDescriptors } from './shared';
 
 /**
  * Places, orders, order configs, service rates, service areas, zones,
@@ -7,67 +8,7 @@ import { first, present, relation, icon, colourTile, fact, relatedFact, money, j
  */
 export default function buildOperationsDescriptors(owner) {
     return [
-        {
-            key: 'place',
-            labelKey: 'resource.place',
-            icon: 'location-dot',
-            modelNames: ['place'],
-            polymorphicTypes: ['fleet-ops:place', 'Fleetbase\\FleetOps\\Models\\Place'],
-            permission: 'fleet-ops view place',
-            title: (place) => first(place, 'displayName', 'name', 'address', 'street1', 'public_id'),
-            identifier: (place) => join([first(place, 'city'), first(place, 'country')], ', ') ?? first(place, 'public_id'),
-            image: () => icon('location-dot'),
-            selectDetails: (place) => [first(place, 'address', 'street1'), join([first(place, 'city'), first(place, 'country')], ', ')],
-            facts: (place) => [
-                fact('address', first(place, 'address', 'street1')),
-                fact('phone', first(place, 'phone')),
-                fact('type', first(place, 'type'), { format: 'humanize' }),
-                relatedFact('vendor', relation(owner, place, 'vendor'), 'vendor', first(place, 'vendor_name')),
-                fact('coordinates', first(place, 'positionString') ?? (present(get(place, 'latitude')) ? `${get(place, 'latitude')}, ${get(place, 'longitude')}` : null)),
-            ],
-            open: panelOpener(owner, 'place-actions'),
-        },
-        {
-            key: 'order',
-            labelKey: 'resource.order',
-            icon: 'box',
-            modelNames: ['order'],
-            polymorphicTypes: ['fleet-ops:order', 'Fleetbase\\FleetOps\\Models\\Order'],
-            permission: 'fleet-ops view order',
-            statusTones: {
-                created: 'text-gray-400',
-                preparing: 'text-yellow-500',
-                dispatched: 'text-yellow-500',
-                started: 'text-yellow-500',
-                in_progress: 'text-yellow-500',
-                enroute: 'text-yellow-500',
-                completed: 'text-green-500',
-                delivered: 'text-green-500',
-                canceled: 'text-red-500',
-                cancelled: 'text-red-500',
-                failed: 'text-red-500',
-            },
-            title: (order) => first(order, 'tracking', 'tracking_number.tracking_number', 'public_id'),
-            identifier: (order) => first(order, 'public_id', 'internal_id'),
-            image: () => icon('box'),
-            status: (order) => first(order, 'status'),
-            selectDetails: (order) => [first(order, 'public_id'), first(order, 'status')],
-            facts: (order) => [
-                fact('status', first(order, 'status'), { format: 'humanize' }),
-                relatedFact('customer', relation(owner, order, 'customer'), polymorphicType(order, 'customer', 'customer_type'), first(order, 'customer_name')),
-                relatedFact('driver', relation(owner, order, 'driver_assigned'), 'driver', first(order, 'driver_name')),
-                fact('route', join([first(order, 'pickupName', 'pickup_name'), first(order, 'dropoffName', 'dropoff_name')], ' → ')),
-                fact('scheduled', get(order, 'scheduled_at'), { format: 'date' }),
-                fact('order-config', first(order, 'order_config.name', 'type')),
-            ],
-            open: (order) => {
-                if (!order || order.isIdentityStub || !first(order, 'id', 'uuid')) {
-                    return false;
-                }
-
-                return panelOpener(owner, 'order-actions')(order);
-            },
-        },
+        ...sharedDescriptors(owner, ['place', 'order']),
         {
             key: 'order-config',
             labelKey: 'resource.order-config',

package/addon/utils/resource-descriptors/people.js

@@ -1,88 +1,13 @@
 import { get } from '@ember/object';
-import { first, present, relation, photo, badge, badges, fact, relatedFact, join, panelOpener, dateLabel, typeLabel } from './helpers';
+import { first, photo, fact, panelOpener } from './helpers';
+import { sharedDescriptors } from './shared';
 
 /**
  * Drivers, vendors, contacts, customers and fleets.
  */
 export default function buildPeopleDescriptors(owner) {
     return [
-        {
-            key: 'driver',
-            labelKey: 'resource.driver',
-            icon: 'id-card',
-            modelNames: ['driver'],
-            aliases: ['attachable-driver', 'facilitator-driver', 'fleet-driver'],
-            polymorphicTypes: ['fleet-ops:driver', 'Fleetbase\\FleetOps\\Models\\Driver'],
-            permission: 'fleet-ops view driver',
-            statusTones: {
-                available: 'text-green-500',
-                active: 'text-green-500',
-                on_duty: 'text-green-500',
-                busy: 'text-yellow-500',
-                assigned: 'text-yellow-500',
-                unavailable: 'text-gray-400',
-                offline: 'text-gray-400',
-                suspended: 'text-red-500',
-            },
-            title: (driver) => first(driver, 'name', 'displayName', 'display_name', 'public_id'),
-            identifier: (driver) => first(driver, 'phone', 'email'),
-            image: (driver) => photo(driver, 'driver'),
-            online: (driver) => {
-                const online = get(driver, 'online');
-
-                return typeof online === 'boolean' ? online : undefined;
-            },
-            status: (driver) => first(driver, 'status'),
-            badges: (driver) => {
-                const vehicle = relation(owner, driver, 'vehicle');
-                const label = first(vehicle, 'displayName', 'display_name', 'name') ?? first(driver, 'vehicle_assigned.display_name', 'vehicle_name');
-
-                return badges(badge('vehicle', 'car', label, { relatedType: 'vehicle', relatedId: vehicle?.id ?? get(driver, 'vehicle_uuid') }));
-            },
-            selectDetails: (driver) => [first(driver, 'phone'), first(driver, 'email')],
-            facts: (driver) => [
-                fact('phone', first(driver, 'phone')),
-                fact('email', first(driver, 'email')),
-                relatedFact('vehicle', relation(owner, driver, 'vehicle'), 'vehicle', first(driver, 'vehicle_name')),
-                fact(
-                    'licence',
-                    join(
-                        [
-                            first(driver, 'drivers_license_number'),
-                            dateLabel(get(driver, 'license_expiry'), 'dd MMM yyyy') ? `expires ${dateLabel(get(driver, 'license_expiry'), 'dd MMM yyyy')}` : null,
-                        ],
-                        ' · '
-                    )
-                ),
-                relatedFact('vendor', relation(owner, driver, 'vendor'), 'vendor', first(driver, 'vendor_name')),
-                fact('status', first(driver, 'status'), { format: 'humanize' }),
-            ],
-            open: panelOpener(owner, 'driver-actions'),
-            components: { identity: 'cell/driver-identity' },
-        },
-        {
-            key: 'vendor',
-            labelKey: 'resource.vendor',
-            icon: 'building',
-            modelNames: ['vendor'],
-            aliases: ['facilitator-vendor', 'customer-vendor'],
-            polymorphicTypes: ['fleet-ops:vendor', 'Fleetbase\\FleetOps\\Models\\Vendor'],
-            permission: 'fleet-ops view vendor',
-            title: (vendor) => first(vendor, 'name', 'public_id'),
-            identifier: (vendor) => first(vendor, 'prettyType', 'internal_id', 'business_id'),
-            image: (vendor) => photo(vendor, 'vendor', 'logo_url'),
-            status: (vendor) => first(vendor, 'status'),
-            selectDetails: (vendor) => [first(vendor, 'email'), first(vendor, 'phone')],
-            facts: (vendor) => [
-                fact('type', first(vendor, 'prettyType', 'type'), { format: 'humanize' }),
-                fact('email', first(vendor, 'email')),
-                fact('phone', first(vendor, 'phone')),
-                fact('website', first(vendor, 'website_url')),
-                fact('address', first(vendor, 'address', 'place.address', 'address_street')),
-                fact('country', first(vendor, 'country')),
-            ],
-            open: panelOpener(owner, 'vendor-actions'),
-        },
+        ...sharedDescriptors(owner, ['driver', 'vendor', 'contact', 'customer', 'fleet']),
         {
             key: 'integrated-vendor',
             labelKey: 'resource.integrated-vendor',
@@ -105,69 +30,5 @@ export default function buildPeopleDescriptors(owner) {
             ],
             open: panelOpener(owner, 'integrated-vendor-actions'),
         },
-        {
-            key: 'contact',
-            labelKey: 'resource.contact',
-            icon: 'address-book',
-            modelNames: ['contact'],
-            aliases: ['facilitator-contact', 'customer-contact'],
-            polymorphicTypes: ['fleet-ops:contact', 'Fleetbase\\FleetOps\\Models\\Contact'],
-            permission: 'fleet-ops view contact',
-            title: (contact) => first(contact, 'name', 'public_id'),
-            identifier: (contact) => first(contact, 'title') ?? typeLabel(first(contact, 'type')),
-            image: (contact) => photo(contact, 'contact'),
-            selectDetails: (contact) => [first(contact, 'email'), first(contact, 'phone')],
-            facts: (contact) => [
-                fact('title', first(contact, 'title')),
-                fact('email', first(contact, 'email')),
-                fact('phone', first(contact, 'phone')),
-                relatedFact('place', relation(owner, contact, 'place'), 'place', first(contact, 'address', 'place.address')),
-                relatedFact('user', relation(owner, contact, 'user'), 'user', first(contact, 'user.name')),
-            ],
-            open: panelOpener(owner, 'contact-actions'),
-        },
-        {
-            key: 'customer',
-            labelKey: 'resource.customer',
-            icon: 'user-tag',
-            modelNames: ['customer'],
-            aliases: ['facilitator-customer'],
-            polymorphicTypes: ['fleet-ops:customer', 'Fleetbase\\FleetOps\\Models\\Customer'],
-            permission: 'fleet-ops view contact',
-            title: (customer) => first(customer, 'name', 'public_id'),
-            identifier: (customer) => typeLabel(first(customer, 'customer_type', 'type')) ?? 'Customer',
-            image: (customer) => photo(customer, 'customer'),
-            selectDetails: (customer) => [first(customer, 'email'), first(customer, 'phone')],
-            facts: (customer) => [
-                fact('type', typeLabel(first(customer, 'customer_type', 'type'))),
-                fact('email', first(customer, 'email')),
-                fact('phone', first(customer, 'phone')),
-                fact('address', first(customer, 'address', 'address_street')),
-                relatedFact('place', relation(owner, customer, 'place'), 'place', first(customer, 'place.address')),
-            ],
-            open: panelOpener(owner, 'customer-actions'),
-        },
-        {
-            key: 'fleet',
-            labelKey: 'resource.fleet',
-            icon: 'layer-group',
-            modelNames: ['fleet'],
-            polymorphicTypes: ['fleet-ops:fleet', 'Fleetbase\\FleetOps\\Models\\Fleet'],
-            permission: 'fleet-ops view fleet',
-            title: (fleet) => first(fleet, 'name', 'public_id'),
-            identifier: (fleet) => first(fleet, 'task', 'public_id'),
-            image: (fleet) => photo(fleet, 'fleet'),
-            status: (fleet) => first(fleet, 'status'),
-            selectDetails: (fleet) => [first(fleet, 'task'), present(get(fleet, 'drivers_count')) ? `${get(fleet, 'drivers_count')} drivers` : null],
-            facts: (fleet) => [
-                fact('task', first(fleet, 'task')),
-                relatedFact('service-area', relation(owner, fleet, 'service_area'), 'service-area', first(fleet, 'service_area.name')),
-                relatedFact('zone', relation(owner, fleet, 'zone'), 'zone', first(fleet, 'zone.name')),
-                relatedFact('vendor', relation(owner, fleet, 'vendor'), 'vendor', first(fleet, 'vendor.name')),
-                fact('drivers', present(get(fleet, 'drivers_count')) ? `${get(fleet, 'drivers_online_count') ?? 0} online of ${get(fleet, 'drivers_count')}` : null),
-                fact('vehicles', present(get(fleet, 'vehicles_count')) ? `${get(fleet, 'vehicles_online_count') ?? 0} online of ${get(fleet, 'vehicles_count')}` : null),
-            ],
-            open: panelOpener(owner, 'fleet-actions'),
-        },
     ];
 }

package/addon/utils/resource-descriptors/shared.js

@@ -0,0 +1,18 @@
+import { buildSharedResourceDescriptors, guardOrder } from '@fleetbase/fleetops-data/utils/resource-descriptors';
+import { panelOpener } from './helpers';
+
+/**
+ * The descriptors `@fleetbase/fleetops-data` shares with every extension,
+ * opened through this engine's own action services instead of through a
+ * lazy engine load: inside FleetOps the services are already here, and the
+ * registry keeps these richer versions over the shared ones.
+ */
+export function sharedDescriptors(owner, keys) {
+    const byKey = Object.fromEntries(buildSharedResourceDescriptors(owner).map((descriptor) => [descriptor.key, descriptor]));
+
+    return keys.map((key) => {
+        const open = panelOpener(owner, `${key}-actions`);
+
+        return { ...byKey[key], canOpen: undefined, open: key === 'order' ? guardOrder(open) : open };
+    });
+}

package/addon/utils/tracking-live-source.js

@@ -0,0 +1,123 @@
+/**
+ * Keeps the public tracking page current.
+ *
+ * `start(onUpdate, onState)` calls `load()` on a schedule and hands each result to
+ * `onUpdate`; `onState` hears `live`, `reconnecting` or `paused`. It polls every 20
+ * seconds while the delivery is moving and every 60 otherwise, pauses while the tab is
+ * hidden, and backs off up to 2 minutes when requests fail. A socket source can replace
+ * it later with the same two callbacks.
+ */
+export const ACTIVE_INTERVAL = 20000;
+export const IDLE_INTERVAL = 60000;
+export const MAX_BACKOFF = 120000;
+
+export default class TrackingLiveSource {
+    constructor(load, { isActive = () => true, documentRef = typeof document === 'undefined' ? null : document } = {}) {
+        this.load = load;
+        this.isActive = isActive;
+        this.document = documentRef;
+        this.timer = null;
+        this.failures = 0;
+        this.running = false;
+        this.onVisibility = () => this.visibilityChanged();
+    }
+
+    start(onUpdate, onState = () => {}) {
+        this.onUpdate = onUpdate;
+        this.onState = onState;
+        this.running = true;
+        this.document?.addEventListener('visibilitychange', this.onVisibility);
+        this.schedule();
+    }
+
+    stop() {
+        this.running = false;
+        clearTimeout(this.timer);
+        this.timer = null;
+        this.document?.removeEventListener('visibilitychange', this.onVisibility);
+    }
+
+    get hidden() {
+        return this.document?.visibilityState === 'hidden';
+    }
+
+    get delay() {
+        if (this.failures > 0) {
+            return Math.min(MAX_BACKOFF, ACTIVE_INTERVAL * Math.pow(2, this.failures - 1));
+        }
+
+        return this.isActive() ? ACTIVE_INTERVAL : IDLE_INTERVAL;
+    }
+
+    schedule() {
+        clearTimeout(this.timer);
+        if (!this.running || this.hidden) {
+            return;
+        }
+
+        this.timer = setTimeout(() => this.tick(), this.delay);
+    }
+
+    async tick() {
+        if (!this.running) {
+            return;
+        }
+
+        try {
+            const result = await this.load();
+            this.failures = 0;
+            this.onState('live');
+            this.onUpdate(result);
+        } catch {
+            this.failures += 1;
+            this.onState('reconnecting');
+        }
+
+        this.schedule();
+    }
+
+    visibilityChanged() {
+        if (this.hidden) {
+            clearTimeout(this.timer);
+            this.onState?.('paused');
+            return;
+        }
+
+        this.tick();
+    }
+}
+
+/**
+ * An encoded polyline (precision 5, as Google Routes and OSRM return it) as [lat, lng] pairs.
+ */
+export function decodePolyline(encoded) {
+    if (typeof encoded !== 'string' || encoded === '') {
+        return [];
+    }
+
+    const points = [];
+    let index = 0;
+    let lat = 0;
+    let lng = 0;
+
+    while (index < encoded.length) {
+        const deltas = [];
+        for (let axis = 0; axis < 2; axis++) {
+            let result = 0;
+            let shift = 0;
+            let byte;
+            do {
+                byte = encoded.charCodeAt(index++) - 63;
+                result |= (byte & 0x1f) << shift;
+                shift += 5;
+            } while (byte >= 0x20 && index < encoded.length);
+            deltas.push(result & 1 ? ~(result >> 1) : result >> 1);
+        }
+
+        lat += deltas[0];
+        lng += deltas[1];
+        points.push([lat / 1e5, lng / 1e5]);
+    }
+
+    return points;
+}