Displaying BedType from vPIC Without Inventing Truck Bed Marketing

#webdev #cars #beginners #typescript

NHTSA vPIC often returns a BedType field on DecodeVinValues-style payloads: catalog phrases such as "Short", "Long", "Standard", or other bed-oriented tokens tied to the VIN pattern. That string is useful on a free VIN decode card for pickups and similar body styles. The trap is turning it into truck bed marketing -- "6.5 ft work bed," "crew + long bed package," "hauls a full sheet of plywood" -- that the BedType field never asserted.

This post is about honest display: show BedType when vPIC provides it, refuse length and lifestyle inventing, and allow a clean "not provided" state when the field is empty. Keep bed catalog labels separate from CabType, BodyClass, and brochure bed-length charts.

What BedType is (and is not)

BedType is a catalog attribute associated with the VIN decode. It answers a narrow question: which bed-type label did the decode associate with this pattern?

It does not answer:

Exact bed length in feet or inches (unless the raw string itself contains that text from vPIC)
Payload remaining after passengers and gear
Whether the truck can haul ATVs, dirt bikes, or "weekend lumber"
Cab configuration (crew, double, regular) -- that is a different field
Lifestyle copy ("ranch ready," "job-site hero") derived from Short/Long tokens

Empty BedType does not mean "standard bed" in a way that authorizes you to invent a length. It means vPIC did not give you that field. Do not fill the gap from BodyClass folklore or from a static bed chart keyed only by Make/Model/Year.

Normalize empties, do not invent bed lengths

Treat blank, "Not Applicable", "N/A", and similar tokens as missing. Do not rewrite "Short" into "5.5 ft" or append "sheet of plywood" because a brochure listed that combination for a different trim.

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

export type BedTypeView = {
  label: string | null;
  source: "vpic" | "missing";
};

export function viewBedType(fields: {
  BedType?: string | null;
}): BedTypeView {
  const raw = (fields.BedType ?? "").trim();
  if (!raw || EMPTY.has(raw.toLowerCase())) {
    return { label: null, source: "missing" };
  }
  // Keep the catalog token; do not coerce into feet / hauling claims.
  return { label: raw, source: "vpic" };
}

export function bedTypeLines(view: BedTypeView): string[] {
  if (view.source === "missing" || !view.label) {
    return ["Bed type: not provided by vPIC for this VIN"];
  }
  return [
    `Bed type (vPIC): ${view.label}`,
    "Catalog label only -- not a measured bed length or cargo pitch",
  ];
}

The footnote matters. Buyers scanning a pickup decode will over-read any bed-shaped word. If vPIC said "Long", show "Long" with sourcing. If blank, say "not provided" -- no greyed "6.5 ft" placeholder pulled from a marketing table.

Forbidden upgrades

Product pressure often asks for:

Mapping Short/Long into hard-coded feet (5.5, 6.5, 8.0) without a sourced length field
Inferring "hauls a full sheet of plywood" from BedType alone
Merging BedType with CabType into "Crew Cab Long Bed" when either field is missing
Defaulting blank BedType to "Standard" so truck inventory UIs never look empty
Turning BedType into a payload or GVWR slogan

Refuse those. If you show CabType, BodyClass, or GVWR from other sourced fields, show each on its own row. Never invent bed arithmetic in the mapper.

export function assertNoBedMarketing(moduleSource: string): void {
  const banned = [
    /\d+(\.\d+)?\s*(ft|feet|in|inch)/i,
    /sheet\s+of\s+plywood/i,
    /hauls?\s+(atvs?|dirt\s*bikes?|lumber)/i,
    /crew\s*\+\s*long\s*bed/i,
    /job[-\s]?site\s+hero/i,
  ];
  for (const re of banned) {
    if (re.test(moduleSource)) {
      throw new Error(
        `BedType display must not invent bed marketing: ${re}`,
      );
    }
  }
}

export function cardRows(fields: {
  BedType?: string | null;
  CabType?: string | null;
  BodyClass?: string | null;
}): { label: string; value: string }[] {
  const bed = viewBedType(fields);
  const cab = (fields.CabType ?? "").trim();
  const body = (fields.BodyClass ?? "").trim();
  const rows: { label: string; value: string }[] = [];

  if (bed.source === "vpic" && bed.label) {
    rows.push({ label: "Bed type (vPIC)", value: bed.label });
  } else {
    rows.push({ label: "Bed type (vPIC)", value: "not provided" });
  }

  if (cab && !EMPTY.has(cab.toLowerCase())) {
    rows.push({ label: "Cab type (vPIC)", value: cab });
  }
  if (body && !EMPTY.has(body.toLowerCase())) {
    rows.push({ label: "Body class (vPIC)", value: body });
  }

  return rows;
}

Separate rows keep attribution clear. A single "Truck package" chip that secretly combines BedType and CabType is how marketing sneaks past review.

When to hide the row entirely

You may always show "not provided" or omit the row on clearly non-pickup BodyClass values. Either is fine if you do not invent. Never fill a blank with a bed-length upsell.

Small tests that lock honesty

import assert from "node:assert/strict";

assert.equal(viewBedType({ BedType: "Long" }).source, "vpic");
assert.equal(viewBedType({ BedType: "N/A" }).source, "missing");
assert.equal(viewBedType({ BedType: "" }).source, "missing");

assert.ok(
  bedTypeLines(viewBedType({ BedType: "Short" })).some((l) =>
    /not a measured bed length/i.test(l),
  ),
);
assert.ok(
  !bedTypeLines(viewBedType({ BedType: "Short" })).some((l) =>
    /ft|plywood|hauls/i.test(l),
  ),
);

const rows = cardRows({
  BedType: "",
  CabType: "Crew/SuperCrew/Crew Max",
  BodyClass: "Pickup",
});
assert.ok(
  rows.some((r) => r.label.includes("Bed type") && r.value === "not provided"),
);
assert.ok(rows.some((r) => r.label.includes("Cab type")));
assert.ok(!rows.some((r) => /\d+\s*ft|Crew \+ Long/i.test(r.value)));

Add a review rule: the BedType module must not contain measured-length or hauling marketing phrases except in tests that forbid them. For chips, show the catalog type with a "Bed type" label -- never upgrade a blank into "Standard 6.5 ft."

Takeaway

BedType is a catalog label. Display it with clear sourcing, allow "not provided," and never use it as a key into invented bed lengths or cargo pitches. Your free VIN UI stays trustworthy when bed type is either a real vPIC value with a modest footnote -- or absent -- and truck bed marketing lives somewhere else, clearly labeled, or not at all.

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

DEV Community