@fleetbase/fleetops-engine 0.6.64 → 0.6.66

package/addon/utils/inspection-answers.js

@@ -0,0 +1,283 @@
+/**
+ * Reading an inspection's answers.
+ *
+ * The sheet, its section headers and its running total all need the same
+ * questions answered — did this row pass, is a required row still blank, is
+ * anything on this form unsafe to operate — and they must agree, so they ask
+ * here rather than each working it out from the raw value.
+ *
+ * The rules mirror the driver app's `src/v3/data/useInspections.ts`, so a form
+ * filled in from a phone and the same form filled in from the console are
+ * counted the same way.
+ */
+
+import { flattenFields } from './inspection-form-structure';
+import { valueTypeForFieldType } from './inspection-field-types';
+
+/** A pass-fail answer, in one shape whatever was stored. */
+export function passFailAnswer(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+
+    // The first cut stored a bare boolean.
+    if (typeof value === 'boolean') {
+        return { passed: value, not_applicable: false };
+    }
+
+    return null;
+}
+
+/**
+ * What a pass-fail row currently says: `pass`, `fail`, `na`, or null when the
+ * field is not a pass-fail field at all.
+ */
+export function answerState(field, value) {
+    if (field?.type !== 'pass-fail') {
+        return null;
+    }
+
+    const answer = passFailAnswer(value);
+    if (!answer) {
+        return null;
+    }
+
+    if (answer.not_applicable === true) {
+        return 'na';
+    }
+
+    return answer.passed === false ? 'fail' : 'pass';
+}
+
+/** Whether a failed row was marked unsafe to operate. */
+export function isUnsafeAnswer(field, value) {
+    return answerState(field, value) === 'fail' && passFailAnswer(value)?.unsafe === true;
+}
+
+/**
+ * Whether a required field is still waiting for an answer.
+ *
+ * A pass-fail row is never blank — it opens on Pass, which is what the driver
+ * app does too — and a toggle is never blank, because off is an answer.
+ */
+export function isBlank(field, value) {
+    if (field?.type === 'pass-fail' || field?.type === 'boolean') {
+        return false;
+    }
+
+    if (value === null || value === undefined || value === '') {
+        return true;
+    }
+
+    return Array.isArray(value) && value.length === 0;
+}
+
+/** Whether a failed row is still missing the comment or photo its field demands. */
+export function defectIncomplete(field, value) {
+    if (answerState(field, value) !== 'fail') {
+        return false;
+    }
+
+    const meta = field?.meta && typeof field.meta === 'object' ? field.meta : {};
+    const answer = passFailAnswer(value) ?? {};
+
+    if (meta.require_comment_on_fail === true && !String(answer.comments ?? '').trim()) {
+        return true;
+    }
+
+    return meta.require_photo_on_fail === true && !(Array.isArray(answer.photos) && answer.photos.length > 0);
+}
+
+/** The types that always need the full width of a group, whatever the answer. */
+export const ROOMY_FIELD_TYPES = ['textarea', 'file-upload', 'signature'];
+
+/**
+ * Whether a field spans the full width of its group's grid.
+ *
+ * Only the types whose size the form itself decides: a note, an upload, a
+ * signature. It depends on the field and never on the answer, so answering a
+ * field can never change the layout. A failure's detail used to widen its
+ * field too, which re-flowed the group every time a check failed; it now
+ * opens in a flyout instead, and the field stays the size it was.
+ */
+// eslint-disable-next-line no-unused-vars
+export function isPromoted(field, value) {
+    return ROOMY_FIELD_TYPES.includes(field?.type);
+}
+
+/**
+ * What a failed check has recorded, in one shape: for the chip a closed
+ * failure leaves behind in its field, and for the defects tray.
+ */
+export function defectSummary(field, value) {
+    const answer = passFailAnswer(value) ?? {};
+    const photos = Array.isArray(answer.photos) ? answer.photos : [];
+    const meta = field?.meta && typeof field.meta === 'object' ? field.meta : {};
+    const hasComment = Boolean(String(answer.comments ?? '').trim());
+
+    return {
+        field,
+        severity: answer.severity ?? meta.severity ?? null,
+        unsafe: answer.unsafe === true,
+        photoCount: photos.length,
+        hasComment,
+        needsComment: meta.require_comment_on_fail === true && !hasComment,
+        needsPhoto: meta.require_photo_on_fail === true && photos.length === 0,
+        incomplete: defectIncomplete(field, value),
+    };
+}
+
+/** Every failed check on the sheet, in the order they are answered. */
+export function listDefects(fields = [], values = {}) {
+    return fields.filter((field) => answerState(field, values?.[field.uuid]) === 'fail').map((field) => defectSummary(field, values?.[field.uuid]));
+}
+
+/**
+ * The one-word state a group header's dot shows for a field: `pass`, `fail`,
+ * `na`, `outstanding` (required and unanswered, or a failure still owing its
+ * comment or photo), `done`, or `empty`.
+ */
+export function fieldMarker(field, value) {
+    const state = answerState(field, value);
+
+    if (state === 'fail') {
+        return defectIncomplete(field, value) ? 'outstanding' : 'fail';
+    }
+
+    if (state) {
+        return state;
+    }
+
+    if (field?.required && isBlank(field, value)) {
+        return 'outstanding';
+    }
+
+    return isBlank(field, value) ? 'empty' : 'done';
+}
+
+/**
+ * The totals a section header and the sheet's foot both read.
+ *
+ * `outstanding` is what still stops the sheet being finished: a required field
+ * left blank, or a failure that owes a comment or a photo.
+ */
+export function summarize(fields = [], values = {}) {
+    const summary = {
+        total: fields.length,
+        checks: 0,
+        passed: 0,
+        failed: 0,
+        notApplicable: 0,
+        missingRequired: 0,
+        incompleteDefects: 0,
+        unsafe: false,
+        unsafeField: null,
+        firstOutstanding: null,
+    };
+
+    for (const field of fields) {
+        const value = values?.[field.uuid];
+        const state = answerState(field, value);
+
+        if (state) {
+            summary.checks += 1;
+
+            if (state === 'pass') {
+                summary.passed += 1;
+            } else if (state === 'fail') {
+                summary.failed += 1;
+            } else {
+                summary.notApplicable += 1;
+            }
+        }
+
+        if (field.required && isBlank(field, value)) {
+            summary.missingRequired += 1;
+        }
+
+        if (defectIncomplete(field, value)) {
+            summary.incompleteDefects += 1;
+        }
+
+        // The banners name the field rather than counting it, so an inspector
+        // is told what to go and fix, not how many things are wrong.
+        if (!summary.firstOutstanding && fieldMarker(field, value) === 'outstanding') {
+            summary.firstOutstanding = field;
+        }
+
+        if (isUnsafeAnswer(field, value)) {
+            summary.unsafe = true;
+
+            if (!summary.unsafeField) {
+                summary.unsafeField = field;
+            }
+        }
+    }
+
+    summary.outstanding = summary.missingRequired + summary.incompleteDefects;
+
+    return summary;
+}
+
+/**
+ * The answer every field starts with.
+ *
+ * A pass-fail row opens on Pass, so a sheet saved untouched still files a
+ * complete set — which is what the driver app does, and what the first cut of
+ * the console did. Everything else starts empty.
+ */
+export function seedAnswers(groups = [], stored = {}) {
+    return flattenFields(groups).reduce((carry, field) => {
+        if (stored?.[field.uuid] !== undefined) {
+            carry[field.uuid] = stored[field.uuid];
+            return carry;
+        }
+
+        carry[field.uuid] = field.type === 'pass-fail' ? { passed: true, not_applicable: false, severity: null, comments: '', photos: [], unsafe: false } : null;
+
+        return carry;
+    }, {});
+}
+
+/**
+ * A file value is a reference on the way out, whichever way it came in: the
+ * `file:<uuid>` a fresh upload leaves, or the `{ id, url, … }` the submission
+ * resource resolved a stored reference to.
+ */
+function serializeFile(value) {
+    if (value && typeof value === 'object') {
+        return value.id ?? null;
+    }
+
+    return typeof value === 'string' && value !== '' ? value : null;
+}
+
+function serializeValue(field, value) {
+    if (field.type === 'pass-fail') {
+        const answer = passFailAnswer(value) ?? { passed: true, not_applicable: false };
+
+        return {
+            ...answer,
+            photos: (Array.isArray(answer.photos) ? answer.photos : []).map(serializeFile).filter(Boolean),
+        };
+    }
+
+    if (field.type === 'file-upload' || field.type === 'signature') {
+        return serializeFile(value);
+    }
+
+    return value;
+}
+
+/**
+ * The answers as the server takes them — the same `custom_field_values` body
+ * the driver API accepts, so the console, a public link and the app all file
+ * the same rows and the item results are derived from the same place.
+ */
+export function answerRows(fields = [], values = {}) {
+    return fields.map((field) => ({
+        custom_field: field.uuid,
+        value_type: valueTypeForFieldType(field.type),
+        value: serializeValue(field, values?.[field.uuid]),
+    }));
+}

package/addon/utils/inspection-field-types.js

@@ -0,0 +1,74 @@
+/**
+ * The field types an inspection form may be built from.
+ *
+ * This list mirrors `Fleetbase\FleetOps\Models\InspectionForm::FIELD_TYPES`
+ * exactly — the server refuses anything else and falls back to `input`, so the
+ * builder must not offer a type the writer will silently rewrite.
+ */
+export const INSPECTION_FIELD_TYPES = ['pass-fail', 'input', 'textarea', 'number', 'select', 'radio-button', 'boolean', 'date-picker', 'date-time-input', 'file-upload', 'signature'];
+
+/** The severities a failed pass-fail answer can carry. */
+export const INSPECTION_SEVERITIES = ['low', 'medium', 'high', 'critical'];
+
+/** The types whose answer is chosen from a list the author writes. */
+export const OPTION_FIELD_TYPES = ['select', 'radio-button'];
+
+/**
+ * The types FleetOps renders itself. `pass-fail`, `signature` and the
+ * inspection flavour of `file-upload` are inspection-only; `textarea`,
+ * `number` and `boolean` are ordinary but absent from the platform's
+ * custom-field type map, so there is nothing to delegate them to.
+ */
+export const FLEETOPS_OWNED_FIELD_TYPES = ['pass-fail', 'signature', 'file-upload', 'textarea', 'number', 'boolean'];
+
+/** The types the platform's own `custom-field/input` already renders. */
+export const DELEGATED_FIELD_TYPES = ['input', 'select', 'radio-button', 'date-picker', 'date-time-input'];
+
+/**
+ * The console component that renders a field type. Mirrors
+ * `InspectionFormSync::componentFor()` so a field built here and a field
+ * converted from the first cut's checklist name the same component.
+ */
+export function componentForFieldType(type) {
+    return type === 'radio-button' ? 'radio-button-select' : type;
+}
+
+/**
+ * How the server stores an answer of this type — the `value_type` a submitted
+ * `custom_field_values` row carries. Mirrors `InspectionSubmitter::normalizeValue()`
+ * and the app's own `valueTypeFor` in `src/v3/data/useInspections.ts`, so the
+ * console and the driver app file the same rows.
+ */
+export function valueTypeForFieldType(type) {
+    switch (type) {
+        case 'pass-fail':
+            return 'object';
+        case 'file-upload':
+        case 'signature':
+            return 'file';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'date-picker':
+            return 'date';
+        case 'date-time-input':
+            return 'datetime';
+        default:
+            return 'text';
+    }
+}
+
+/** Whether a field of this type needs the author to write its options. */
+export function isOptionFieldType(type) {
+    return OPTION_FIELD_TYPES.includes(type);
+}
+
+/** Whether FleetOps renders this type itself rather than delegating it. */
+export function isFleetOpsOwnedFieldType(type) {
+    return FLEETOPS_OWNED_FIELD_TYPES.includes(type);
+}
+
+export default function inspectionFieldTypes() {
+    return INSPECTION_FIELD_TYPES;
+}

package/addon/utils/inspection-form-structure.js

@@ -0,0 +1,161 @@
+import generateUuid from '@fleetbase/ember-core/utils/generate-uuid';
+import isObject from '@fleetbase/ember-core/utils/is-object';
+import { componentForFieldType, INSPECTION_FIELD_TYPES } from './inspection-field-types';
+
+/**
+ * A form's structure, in the one shape the console holds it in.
+ *
+ * The `inspection-form` model belongs to `@fleetbase/fleetops-data` and
+ * declares no structure attribute, so the builder cannot hang the groups off
+ * the record and let Ember Data carry them. It reads the structure from the
+ * internal form payload and writes it back whole under
+ * `inspection_form.field_groups`, which is what
+ * `InspectionFormController::syncStructureFromRequest()` looks for and what
+ * `InspectionFormSync::sync()` matches on `uuid`.
+ *
+ * Everything here is plain objects. Nothing in this file mutates its argument.
+ */
+
+/** Sorts groups or fields the way the builder laid them out. */
+function byOrder(a, b) {
+    const ao = a?.order ?? Number.MAX_SAFE_INTEGER;
+    const bo = b?.order ?? Number.MAX_SAFE_INTEGER;
+    return ao - bo;
+}
+
+function metaOf(value) {
+    return isObject(value) ? { ...value } : {};
+}
+
+/** One field, as the builder and the answering screen both read it. */
+export function normalizeField(field, index = 0) {
+    const type = INSPECTION_FIELD_TYPES.includes(field?.type) ? field.type : 'input';
+
+    return {
+        uuid: field?.uuid ?? field?.id ?? generateUuid(),
+        name: field?.name ?? '',
+        label: field?.label ?? '',
+        description: field?.description ?? null,
+        help_text: field?.help_text ?? null,
+        type,
+        component: field?.component ?? componentForFieldType(type),
+        required: Boolean(field?.required),
+        editable: field?.editable === undefined ? true : Boolean(field.editable),
+        options: Array.isArray(field?.options) ? [...field.options] : [],
+        order: field?.order ?? index + 1,
+        meta: metaOf(field?.meta),
+    };
+}
+
+/** One group, with its fields inside it and sorted. */
+export function normalizeGroup(group, index = 0, fields = []) {
+    const own = Array.isArray(group?.fields) ? group.fields : Array.isArray(group?.customFields) ? group.customFields : fields;
+
+    return {
+        uuid: group?.uuid ?? group?.id ?? generateUuid(),
+        name: group?.name ?? '',
+        description: group?.description ?? null,
+        order: group?.order ?? index + 1,
+        meta: { grid_size: 1, ...metaOf(group?.meta) },
+        fields: [...own].sort(byOrder).map((field, fieldIndex) => normalizeField(field, fieldIndex)),
+    };
+}
+
+/**
+ * The structure held in an internal form payload.
+ *
+ * A read carries `field_groups` (the groups alone) beside a flat `fields` list
+ * that names its group by `category_uuid`; `grouped_fields` carries the same
+ * thing already nested, and is what the driver API answers with. Either is
+ * accepted, so this works against a record read through the console and one
+ * read through the public link.
+ */
+export function normalizeFieldGroups(payload) {
+    if (!payload) {
+        return [];
+    }
+
+    const groups = Array.isArray(payload.field_groups) ? payload.field_groups : [];
+    const fields = Array.isArray(payload.fields) ? payload.fields : [];
+
+    const fromFieldGroups = groups
+        .slice()
+        .sort(byOrder)
+        .map((group, index) => {
+            const groupUuid = group?.uuid ?? group?.id;
+            const own = fields.filter((field) => (field?.category_uuid ?? null) === groupUuid);
+            return normalizeGroup(group, index, own);
+        });
+
+    const fromGroupedFields = (Array.isArray(payload.grouped_fields) ? payload.grouped_fields : [])
+        .slice()
+        .sort(byOrder)
+        .map((group, index) => normalizeGroup(group, index));
+
+    /*
+     * Two shapes describe the same structure. `field_groups` carries no fields
+     * of its own — they arrive in the sibling `fields` array, joined on
+     * `category_uuid` — while `grouped_fields` nests them. A public payload
+     * omits `category_uuid`, so the join finds nothing and every group comes
+     * back empty; take whichever shape actually produced fields.
+     *
+     * When neither did, prefer `field_groups`: a form whose groups are laid
+     * out but still empty is a real state in the builder, and returning
+     * nothing would lose those groups.
+     */
+    if (fromFieldGroups.some((group) => group.fields.length > 0)) {
+        return fromFieldGroups;
+    }
+
+    if (fromGroupedFields.some((group) => group.fields.length > 0)) {
+        return fromGroupedFields;
+    }
+
+    return fromFieldGroups.length ? fromFieldGroups : fromGroupedFields;
+}
+
+/** Every field of every group, flattened, in the order they are answered. */
+export function flattenFields(groups = []) {
+    return groups.reduce((carry, group) => carry.concat(Array.isArray(group?.fields) ? group.fields : []), []);
+}
+
+/**
+ * The structure as the server writes it. `order` is rewritten from the
+ * builder's own ordering so a drag or a delete renumbers the whole form, and
+ * the uuid is kept so a second save updates rather than duplicates.
+ */
+export function serializeFieldGroups(groups = []) {
+    return groups.map((group, groupIndex) => ({
+        uuid: group.uuid,
+        name: group.name,
+        description: group.description ?? null,
+        order: groupIndex + 1,
+        meta: metaOf(group.meta),
+        fields: (Array.isArray(group.fields) ? group.fields : []).map((field, fieldIndex) => ({
+            uuid: field.uuid,
+            name: field.name || null,
+            label: field.label,
+            description: field.description ?? null,
+            help_text: field.help_text ?? null,
+            type: field.type,
+            component: componentForFieldType(field.type),
+            required: Boolean(field.required),
+            editable: field.editable === undefined ? true : Boolean(field.editable),
+            options: Array.isArray(field.options) ? field.options.filter((option) => typeof option === 'string' && option.trim() !== '') : [],
+            order: fieldIndex + 1,
+            meta: metaOf(field.meta),
+        })),
+    }));
+}
+
+/** A blank group, ready for the builder to name. */
+export function createFieldGroup(attributes = {}) {
+    return normalizeGroup({ uuid: generateUuid(), name: '', meta: { grid_size: 1 }, fields: [], ...attributes });
+}
+
+/** A blank field of the given type. */
+export function createField(type = 'pass-fail', attributes = {}) {
+    const meta = type === 'pass-fail' ? { severity: 'medium', require_photo_on_fail: false, require_comment_on_fail: false, unsafe_on_fail: false } : {};
+
+    return normalizeField({ uuid: generateUuid(), label: '', type, meta, ...attributes });
+}

package/addon/utils/live-map-card-content.js

@@ -23,6 +23,44 @@ function buildStatusBadge(status, label = status) {
         </div>`;
 }
 
+function escapeHtml(value) {
+    return `${value ?? ''}`.replace(/[&<>"']/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character]);
+}
+
+function toPlainArray(value) {
+    if (!value) {
+        return [];
+    }
+
+    if (typeof value.toArray === 'function') {
+        return value.toArray();
+    }
+
+    return isArray(value) ? Array.from(value) : [];
+}
+
+/**
+ * Stacked list of attached assets (trailers, devices) with an online dot per row,
+ * or a dash when nothing is attached. Names are user data, so they are escaped.
+ */
+function buildAttachmentList(items, resolveName) {
+    if (items.length === 0) {
+        return '-';
+    }
+
+    return items
+        .map((item) => {
+            const onlineClass = item.online ? 'bg-green-400' : 'bg-gray-500';
+
+            return `
+                <div class="flex items-center gap-1 min-w-0">
+                    <span class="inline-block w-1.5 h-1.5 rounded-full shrink-0 ${onlineClass}"></span>
+                    <span class="truncate">${escapeHtml(resolveName(item))}</span>
+                </div>`;
+        })
+        .join('');
+}
+
 function buildMetaCell(label, value, valueClass = '') {
     const shouldTruncate = valueClass.split(' ').includes('truncate');
     const flowClass = shouldTruncate ? 'min-w-0 w-full' : 'whitespace-normal break-words';
@@ -65,6 +103,22 @@ function resolveVehicleNumber(vehicle) {
     return vehicle.internal_id ?? vehicle.public_id ?? vehicle.plate_number ?? vehicle.serial_number ?? vehicle.vin ?? '-';
 }
 
+function resolveTrailerName(trailer) {
+    return trailer.displayName ?? trailer.display_name ?? trailer.name ?? trailer.public_id ?? '-';
+}
+
+function resolveDeviceName(device) {
+    return device.displayName ?? device.display_name ?? device.name ?? device.device_id ?? device.public_id ?? '-';
+}
+
+export function resolveVehicleTrailers(vehicle) {
+    return toPlainArray(vehicle.trailers);
+}
+
+export function resolveVehicleDevices(vehicle) {
+    return toPlainArray(vehicle.devices);
+}
+
 function resolveVehicleStatus(vehicle) {
     return vehicle.meta?.status_label ?? vehicle.current_status ?? vehicle.status ?? '-';
 }
@@ -143,6 +197,8 @@ export function buildVehicleLiveMapContent(vehicle, framed = false) {
             <div class="grid grid-cols-2 gap-1">
                 ${buildMetaCell('Vehicle #', resolveVehicleNumber(vehicle))}
                 ${buildMetaCell('Driver', vehicle.driver_name ?? vehicle.driver?.name ?? '-')}
+                ${buildMetaCell('Trailers', buildAttachmentList(resolveVehicleTrailers(vehicle), resolveTrailerName))}
+                ${buildMetaCell('Devices', buildAttachmentList(resolveVehicleDevices(vehicle), resolveDeviceName))}
                 ${buildMetaCell('Order', vehicle.meta?.current_order_reference ?? '-')}
                 ${buildMetaCell('Speed', resolveVehicleSpeed(vehicle))}
                 ${buildMetaCell('Heading', resolveVehicleHeading(vehicle))}

package/addon/utils/placeholder-images.js

@@ -0,0 +1,71 @@
+import config from 'ember-get-config';
+
+/**
+ * Flat silhouettes shown wherever a resource has no photo, in one consistent style
+ * across the console. They are inline data URIs so the engine does not depend on a
+ * hosted asset; a console can override any of them through
+ * `defaultValues.placeholders.<type>` in its environment config.
+ */
+export const PLACEHOLDER_IMAGES = {
+    trailer:
+        'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2NDAgNDgwIiB3aWR0aD0iNjQwIiBoZWlnaHQ9IjQ4MCI+PGcgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIj48cmVjdCB4PSI4OCIgeT0iMTI4IiB3aWR0aD0iNDcwIiBoZWlnaHQ9IjE5NiIgcng9IjE2IiBmaWxsPSIjYmRiZGJkIiBzdHJva2U9IiNkZWRlZGUiIHN0cm9rZS13aWR0aD0iMTAiLz48cmVjdCB4PSIxMDgiIHk9IjE1MCIgd2lkdGg9IjQzMCIgaGVpZ2h0PSIxNTIiIHJ4PSI4IiBmaWxsPSIjYzljOWM5Ii8+PHBhdGggZD0iTTEyOCAxNzhoMzkwTTEyOCAyMjZoMzkwTTEyOCAyNzRoMzkwIiBzdHJva2U9IiNiZGJkYmQiIHN0cm9rZS13aWR0aD0iNiIvPjxyZWN0IHg9IjUyMiIgeT0iMTQ2IiB3aWR0aD0iMTAiIGhlaWdodD0iMTYwIiByeD0iNCIgZmlsbD0iI2IwYjBiMCIvPjxyZWN0IHg9Ijg4IiB5PSIzMjQiIHdpZHRoPSI0NzAiIGhlaWdodD0iMTgiIHJ4PSI2IiBmaWxsPSIjYTlhOWE5Ii8+PHJlY3QgeD0iMTU2IiB5PSIzNDIiIHdpZHRoPSIxNCIgaGVpZ2h0PSI1MiIgcng9IjQiIGZpbGw9IiNhOWE5YTkiLz48cmVjdCB4PSIxNDYiIHk9IjM5MiIgd2lkdGg9IjM0IiBoZWlnaHQ9IjEwIiByeD0iNCIgZmlsbD0iI2E5YTlhOSIvPjxyZWN0IHg9Ijg4IiB5PSIzNDIiIHdpZHRoPSI1MiIgaGVpZ2h0PSIxNiIgcng9IjYiIGZpbGw9IiNhOWE5YTkiLz48Y2lyY2xlIGN4PSI0MTIiIGN5PSIzNjYiIHI9IjQwIiBmaWxsPSIjOGY4ZjhmIiBzdHJva2U9IiNkZWRlZGUiIHN0cm9rZS13aWR0aD0iOCIvPjxjaXJjbGUgY3g9IjQxMiIgY3k9IjM2NiIgcj0iMTYiIGZpbGw9IiNkOWQ5ZDkiLz48Y2lyY2xlIGN4PSI1MDAiIGN5PSIzNjYiIHI9IjQwIiBmaWxsPSIjOGY4ZjhmIiBzdHJva2U9IiNkZWRlZGUiIHN0cm9rZS13aWR0aD0iOCIvPjxjaXJjbGUgY3g9IjUwMCIgY3k9IjM2NiIgcj0iMTYiIGZpbGw9IiNkOWQ5ZDkiLz48L2c+PC9zdmc+',
+    vehicle:
+        'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2NDAgNDgwIiB3aWR0aD0iNjQwIiBoZWlnaHQ9IjQ4MCI+PGcgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIj48ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIDApIHNjYWxlKDEuMCkiIG9wYWNpdHk9IjEuMCI+PHJlY3QgeD0iMjE2IiB5PSIxMzIiIHdpZHRoPSIzNTAiIGhlaWdodD0iMTkyIiByeD0iMTQiIGZpbGw9IiNiZGJkYmQiIHN0cm9rZT0iI2RlZGVkZSIgc3Ryb2tlLXdpZHRoPSIxMCIvPjxyZWN0IHg9IjIzNiIgeT0iMTU0IiB3aWR0aD0iMzEwIiBoZWlnaHQ9IjE0OCIgcng9IjgiIGZpbGw9IiNjOWM5YzkiLz48cGF0aCBkPSJNMjU2IDE4MmgyNzBNMjU2IDIzMGgyNzBNMjU2IDI3OGgyNzAiIHN0cm9rZT0iI2JkYmRiZCIgc3Ryb2tlLXdpZHRoPSI2Ii8+PHBhdGggZD0iTTIxNiAzMjRWMTkwSDk2Yy0xMiAwLTIyIDgtMjYgMjBMNjAgMjQ0djgweiIgZmlsbD0iI2JkYmRiZCIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjEwIi8+PHBhdGggZD0iTTEwNCAyMDZoODh2NTJIODR6IiBmaWxsPSIjZDlkOWQ5Ii8+PHJlY3QgeD0iNjAiIHk9IjMyNCIgd2lkdGg9IjUwNiIgaGVpZ2h0PSIxOCIgcng9IjYiIGZpbGw9IiNhOWE5YTkiLz48cmVjdCB4PSI1NiIgeT0iMjkyIiB3aWR0aD0iMTgiIGhlaWdodD0iMzAiIHJ4PSI1IiBmaWxsPSIjZDlkOWQ5Ii8+PGNpcmNsZSBjeD0iMTUwIiBjeT0iMzY2IiByPSI0MCIgZmlsbD0iIzhmOGY4ZiIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjgiLz48Y2lyY2xlIGN4PSIxNTAiIGN5PSIzNjYiIHI9IjE2IiBmaWxsPSIjZDlkOWQ5Ii8+PGNpcmNsZSBjeD0iNDcwIiBjeT0iMzY2IiByPSI0MCIgZmlsbD0iIzhmOGY4ZiIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjgiLz48Y2lyY2xlIGN4PSI0NzAiIGN5PSIzNjYiIHI9IjE2IiBmaWxsPSIjZDlkOWQ5Ii8+PC9nPjwvZz48L3N2Zz4=',
+    driver: 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2NDAgNDgwIiB3aWR0aD0iNjQwIiBoZWlnaHQ9IjQ4MCI+PGcgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIj48cGF0aCBkPSJNMTEwIDQ4MGMwLTk2IDc2LTE2NiAyMTAtMTY2czIxMCA3MCAyMTAgMTY2eiIgZmlsbD0iI2JkYmRiZCIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjEwIi8+PHBhdGggZD0iTTI3MCAzMjJsNTAgNTQgNTAtNTQiIGZpbGw9Im5vbmUiIHN0cm9rZT0iI2Q5ZDlkOSIgc3Ryb2tlLXdpZHRoPSI4Ii8+PGNpcmNsZSBjeD0iMzIwIiBjeT0iMjA0IiByPSI5MiIgZmlsbD0iI2JkYmRiZCIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjEwIi8+PHBhdGggZD0iTTIzMCAxODZjMC02MiA0Mi05NiA5MC05NnM5MCAzNCA5MCA5NnoiIGZpbGw9IiNhOWE5YTkiIHN0cm9rZT0iI2RlZGVkZSIgc3Ryb2tlLXdpZHRoPSIxMCIvPjxwYXRoIGQ9Ik0zMjAgOTZ2ODgiIHN0cm9rZT0iI2RlZGVkZSIgc3Ryb2tlLXdpZHRoPSI2Ii8+PGNpcmNsZSBjeD0iMzIwIiBjeT0iOTIiIHI9IjkiIGZpbGw9IiNhOWE5YTkiIHN0cm9rZT0iI2RlZGVkZSIgc3Ryb2tlLXdpZHRoPSI2Ii8+PHBhdGggZD0iTTIyMiAxODZoMTkwYzY2IDAgOTYgMTAgOTYgMjJzLTMwIDIyLTk2IDIySDIyMnoiIGZpbGw9IiNhOWE5YTkiIHN0cm9rZT0iI2RlZGVkZSIgc3Ryb2tlLXdpZHRoPSI4Ii8+PC9nPjwvc3ZnPg==',
+    contact:
+        'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2NDAgNDgwIiB3aWR0aD0iNjQwIiBoZWlnaHQ9IjQ4MCI+PGcgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIj48cGF0aCBkPSJNMTEwIDQ4MGMwLTk2IDc2LTE2NiAyMTAtMTY2czIxMCA3MCAyMTAgMTY2eiIgZmlsbD0iI2JkYmRiZCIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjEwIi8+PHBhdGggZD0iTTI3MCAzMjJsNTAgNTQgNTAtNTQiIGZpbGw9Im5vbmUiIHN0cm9rZT0iI2Q5ZDlkOSIgc3Ryb2tlLXdpZHRoPSI4Ii8+PGNpcmNsZSBjeD0iMzIwIiBjeT0iMTg4IiByPSI5NiIgZmlsbD0iI2JkYmRiZCIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjEwIi8+PC9nPjwvc3ZnPg==',
+    customer:
+        'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2NDAgNDgwIiB3aWR0aD0iNjQwIiBoZWlnaHQ9IjQ4MCI+PGcgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIj48cGF0aCBkPSJNMTEwIDQ4MGMwLTk2IDc2LTE2NiAyMTAtMTY2czIxMCA3MCAyMTAgMTY2eiIgZmlsbD0iI2JkYmRiZCIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjEwIi8+PHBhdGggZD0iTTI3MCAzMjJsNTAgNTQgNTAtNTQiIGZpbGw9Im5vbmUiIHN0cm9rZT0iI2Q5ZDlkOSIgc3Ryb2tlLXdpZHRoPSI4Ii8+PGNpcmNsZSBjeD0iMzIwIiBjeT0iMTg4IiByPSI5NiIgZmlsbD0iI2JkYmRiZCIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjEwIi8+PGNpcmNsZSBjeD0iNDkwIiBjeT0iMzkyIiByPSI2MCIgZmlsbD0iIzhmOGY4ZiIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjEwIi8+PHBhdGggZD0iTTQ1OCAzOTRsMjIgMjIgNDQtNDgiIGZpbGw9Im5vbmUiIHN0cm9rZT0iI2Q5ZDlkOSIgc3Ryb2tlLXdpZHRoPSIxNCIvPjwvZz48L3N2Zz4=',
+    vendor: 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2NDAgNDgwIiB3aWR0aD0iNjQwIiBoZWlnaHQ9IjQ4MCI+PGcgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIj48cGF0aCBkPSJNNzIgMjAwTDMyMCA5NmwyNDggMTA0djI0SDcyeiIgZmlsbD0iI2E5YTlhOSIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjEwIi8+PHJlY3QgeD0iMTAwIiB5PSIyMjIiIHdpZHRoPSI0NDAiIGhlaWdodD0iMTkwIiByeD0iOCIgZmlsbD0iI2JkYmRiZCIgc3Ryb2tlPSIjZGVkZWRlIiBzdHJva2Utd2lkdGg9IjEwIi8+PHJlY3QgeD0iMjcyIiB5PSIyOTIiIHdpZHRoPSI5NiIgaGVpZ2h0PSIxMjAiIHJ4PSI2IiBmaWxsPSIjOGY4ZjhmIiBzdHJva2U9IiNkZWRlZGUiIHN0cm9rZS13aWR0aD0iOCIvPjxyZWN0IHg9IjE0MCIgeT0iMjYyIiB3aWR0aD0iODgiIGhlaWdodD0iNjYiIHJ4PSI2IiBmaWxsPSIjZDlkOWQ5Ii8+PHJlY3QgeD0iNDEyIiB5PSIyNjIiIHdpZHRoPSI4OCIgaGVpZ2h0PSI2NiIgcng9IjYiIGZpbGw9IiNkOWQ5ZDkiLz48cGF0aCBkPSJNMTg0IDI2MnY2Nk0xNDAgMjk1aDg4TTQ1NiAyNjJ2NjZNNDEyIDI5NWg4OCIgc3Ryb2tlPSIjYmRiZGJkIiBzdHJva2Utd2lkdGg9IjYiLz48cmVjdCB4PSI2MCIgeT0iNDEyIiB3aWR0aD0iNTIwIiBoZWlnaHQ9IjE2IiByeD0iNiIgZmlsbD0iI2E5YTlhOSIvPjwvZz48L3N2Zz4=',
+    fleet: 'data:image/svg+xml;base64,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',
+};
+
+/**
+ * Hosted images the data models and console config fall back to when a record has no
+ * photo. Treat them as "no photo" so the styled placeholder wins over the legacy PNG.
+ */
+const LEGACY_DEFAULT_PATTERN = /(no-avatar|vehicle-placeholder|image-file-icon|fallback-placeholder|default-extension-icon)\.(png|svg|jpe?g)/i;
+
+const CONFIG_KEYS = {
+    vehicle: 'vehicleImage',
+    driver: 'driverImage',
+    vendor: 'vendorImage',
+    contact: 'contactImage',
+    customer: 'customerImage',
+    fleet: 'fleetImage',
+    trailer: 'trailerImage',
+};
+
+export function getPlaceholderImage(type = 'contact') {
+    const overrides = config?.defaultValues?.placeholders ?? {};
+    // A console that already replaced its hosted defaults with inline images wins;
+    // hosted PNG defaults are ignored so the silhouette set stays consistent.
+    const configured = config?.defaultValues?.[CONFIG_KEYS[type]];
+    const inlineConfigured = typeof configured === 'string' && configured.startsWith('data:') ? configured : null;
+
+    return overrides[type] || inlineConfigured || PLACEHOLDER_IMAGES[type] || PLACEHOLDER_IMAGES.contact;
+}
+
+export function isDefaultImage(url) {
+    if (typeof url !== 'string' || url.trim() === '') {
+        return true;
+    }
+
+    if (LEGACY_DEFAULT_PATTERN.test(url)) {
+        return true;
+    }
+
+    const defaults = Object.values(config?.defaultValues ?? {}).filter((value) => typeof value === 'string');
+
+    return defaults.includes(url);
+}
+
+/**
+ * The image to show for a record: its own photo, or the styled placeholder when the
+ * photo is missing or one of the legacy hosted defaults.
+ */
+export function resolveResourceImage(url, type) {
+    return isDefaultImage(url) ? getPlaceholderImage(type) : url;
+}
+
+export default getPlaceholderImage;