Showing BlindSpotMon from vPIC Without Inventing ADAS Safety Packages

#webdev #cars #beginners #typescript

NHTSA vPIC often returns ADAS-oriented catalog fields on DecodeVinValues-style payloads -- including BlindSpotMon and related monitor / assistance tokens when the pattern includes them. Those strings are useful on a free VIN decode card. The trap is turning a single sourced field into a "safety package," IIHS-equivalent grade, or brochure ADAS bundle that the catalog never asserted.

This post is about honest display: show BlindSpotMon when vPIC provides it, refuse package inventing, and allow a clean "not provided" state when the field is empty. Keep blind-spot catalog values separate from crash-test scores, recall status, and marketing names for driver-assistance suites. A sourced token is still only a token: it does not prove the feature is present, calibrated, or undamaged on the listed vehicle. (Airbag location honesty is a separate topic; here the focus is BlindSpotMon and close cousins.)

What BlindSpotMon is (and is not)

BlindSpotMon is a catalog attribute associated with the VIN decode. It answers a narrow question: which blind-spot monitoring token did the decode associate with this pattern?

It does not answer:

Whether the vehicle earned an IIHS or NHTSA star rating
Whether a dealer "Safety Package," "Driver Assist," or OEM suite name is equipped
Camera vs radar vs ultrasonic hardware details you did not source
Whether the feature works today, was optioned, or was deleted after manufacture
A composite "ADAS completeness" score built from missing neighboring fields

Empty BlindSpotMon does not authorize a default "Standard" badge, and a positive token does not mean "full ADAS suite verified." Do not fill gaps from Make/Model/Year folklore or a chart keyed only by model year.

Normalize empties, do not invent packages

Treat blank, "Not Applicable", "N/A", and similar tokens as missing. Keep a sourced string when present; do not rewrite it into "Blind Spot + Cross Traffic Package" or an IIHS-style grade.

const EMPTY = new Set([
  "",
  "not applicable",
  "n/a",
  "na",
  "null",
  "none",
  "unknown",
]);

export type BlindSpotMonView = {
  value: string | null;
  source: "vpic" | "missing";
};

export function viewBlindSpotMon(fields: {
  BlindSpotMon?: string | null;
}): BlindSpotMonView {
  const raw = (fields.BlindSpotMon ?? "").trim();
  if (!raw || EMPTY.has(raw.toLowerCase())) {
    return { value: null, source: "missing" };
  }
  return { value: raw, source: "vpic" };
}

export function blindSpotMonLines(view: BlindSpotMonView): string[] {
  if (view.source === "missing") {
    return [
      "Blind spot monitoring: not provided by vPIC for this VIN",
    ];
  }
  return [
    `Blind spot monitoring (vPIC): ${view.value}`,
    "Catalog token only -- not a safety package or IIHS-equivalent claim",
  ];
}

The footnote matters. Buyers over-read a single ADAS field as a verified suite. Show the sourced token; if blank, say "not provided" -- no greyed "Standard" and no invented package name.

Forbidden upgrades

Product pressure often asks for:

Mapping any non-empty BlindSpotMon into "Safety Package included"
Inventing IIHS / Euro NCAP / star-equivalent language from catalog ADAS fields
Bundling BlindSpotMon with ForwardCollisionWarning or LaneDeparture into "Full ADAS"
Defaulting blank BlindSpotMon to "Standard" so mid-trim cars look complete
Renaming catalog tokens into OEM suite marketing names you did not source

Refuse those. If you show other ADAS catalog fields from separate sourced keys, show each on its own row. Never invent a package name inside the BlindSpotMon mapper.

export function assertNoAdasPackageInvent(moduleSource: string): void {
  const banned = [
    /safety package/i,
    /iihs/i,
    /5-star equivalent/i,
    /full adas/i,
    /driver assist suite/i,
    /euro ncap/i,
  ];
  for (const re of banned) {
    if (re.test(moduleSource)) {
      throw new Error(
        `BlindSpotMon module must not invent ADAS packages: ${re}`,
      );
    }
  }
}

export type CardRow = { label: string; value: string };

export function cardRows(fields: {
  BlindSpotMon?: string | null;
  ForwardCollisionWarning?: string | null;
  LaneDepartureWarning?: string | null;
}): CardRow[] {
  const view = viewBlindSpotMon(fields);
  const out: CardRow[] = [];
  if (view.source === "missing") {
    out.push({
      label: "Blind spot monitoring",
      value: "not provided",
    });
  } else {
    out.push({
      label: "Blind spot monitoring",
      value: String(view.value),
    });
  }

  const fcw = (fields.ForwardCollisionWarning ?? "").trim();
  if (fcw && !EMPTY.has(fcw.toLowerCase())) {
    out.push({ label: "Forward collision warning (vPIC)", value: fcw });
  }
  const ldw = (fields.LaneDepartureWarning ?? "").trim();
  if (ldw && !EMPTY.has(ldw.toLowerCase())) {
    out.push({ label: "Lane departure warning (vPIC)", value: ldw });
  }
  return out;
}

Keep neighboring ADAS fields on their own labeled rows. Never concatenate them into "Full Driver Assist Package."

UI copy that stays honest

Prefer:

"Blind spot monitoring (vPIC): Standard"
"Blind spot monitoring: not provided by vPIC for this VIN"
A short footnote: catalog token, not a safety package or rating claim

Avoid:

"Safety Package verified -- IIHS Top Safety Pick equivalent"
"Full ADAS suite from BlindSpotMon"
Grey placeholders that look like real ADAS data when the field was empty

Quick checks

import assert from "node:assert/strict";

assert.equal(viewBlindSpotMon({}).source, "missing");
assert.deepEqual(
  blindSpotMonLines(viewBlindSpotMon({})),
  ["Blind spot monitoring: not provided by vPIC for this VIN"],
);

const std = viewBlindSpotMon({ BlindSpotMon: "Standard" });
assert.equal(std.value, "Standard");
assert.ok(
  blindSpotMonLines(std).some((l) =>
    /not a safety package or IIHS/i.test(l),
  ),
);
assert.ok(
  !blindSpotMonLines(std).some((l) =>
    /safety package|iihs|full adas/i.test(l),
  ),
);

const rows = cardRows({
  BlindSpotMon: "",
  ForwardCollisionWarning: "Standard",
  LaneDepartureWarning: "N/A",
});
assert.ok(
  rows.some(
    (r) =>
      r.label.includes("Blind spot") && r.value === "not provided",
  ),
);
assert.ok(rows.some((r) => r.label.includes("Forward collision")));
assert.ok(!rows.some((r) => /safety package|iihs/i.test(r.value)));

Review rule: BlindSpotMon modules must not contain package or rating marketing phrases except in forbidding tests. Never upgrade a blank into "Standard."

Takeaway

BlindSpotMon is a catalog token. Display it with clear sourcing, allow "not provided," and never use it as a key into invented safety packages, IIHS-equivalent grades, or bundled ADAS suite names. Your free VIN UI stays trustworthy when blind-spot monitoring is either a real vPIC value with a modest footnote -- or absent -- and ADAS marketing lives somewhere else, clearly labeled, or not at all. Catalog honesty beats a complete-looking safety card every time.

I maintain VIN Lookup, a free VIN decode based on NHTSA data.

DEV Community