);
}
// ---------- sections ----------
function Nav({ onHome, onBrowse }) {
const openStoreLanding = onHome || (() => window.__landaiNav ? window.__landaiNav("store") : (location.href = "/data-store"));
const links = [["Mobile App", () => window.__landaiNav ? window.__landaiNav("mobile") : (location.href = "/")], ["Data Store", openStoreLanding], ["About", () => window.__landaiNav ? window.__landaiNav("about") : (location.href = "/about")], ["Contact Us", () => window.__landaiNav ? window.__landaiNav("contact") : (location.href = "/contact")]];
const navItemStyle = (active) => ({
display: "inline-flex",
alignItems: "center",
gap: 7,
fontSize: 15,
fontWeight: active ? 700 : 500,
color: INK,
cursor: "pointer",
opacity: active ? 1 : 0.72,
padding: "7px 11px",
borderRadius: 999,
background: active ? "#fff" : "transparent",
border: active ? `1px solid ${BORDER}` : "1px solid transparent",
boxShadow: active ? "0 8px 18px rgba(16,40,30,0.06)" : "none"
});
const activeDot =
);
}
function ValueBand() {
const cards = [
["Buy exactly the area you need", "One county or a whole state — get parcel data for the geography you're working, and nothing you're not.", "desktop"],
["See the price before you buy", "Every county is priced up front. No quotes, no negotiation, no surprises at checkout.", "phone"],
["Formats that drop into your tools", "Download as FileGDB, Shapefile, GeoPackage, GeoJSON, or CSV — ready for GIS, a spreadsheet, or your own app.", "bulk"],
];
return (
);
}
function HowItWorks() {
const steps = [
["Step 1", "Find your area", "Search or tap the map to pick the county or state you're working in.", "geo"],
["Step 2", "Get every format", "Each county includes FileGDB, Shapefile, GeoPackage, GeoJSON, and CSV.", "options"],
["Step 3", "Review coverage", "Confirm parcel counts, data date, and field completeness before you buy.", "addons"],
["Step 4", "Check out and download", "Pay online and your data's ready to go — straight into mapping, outreach, or analysis.", "checkout"],
];
return (
);
}
function CoveragePreviewGraphic() {
const fieldRows = [
["Owner", 99],
["Site address", 97],
["Sale date", 71],
];
const countyTiles = Array.from({ length: 66 }, (_, i) => {
const col = i % 11;
const row = Math.floor(i / 11);
const supported = ![3, 8, 14, 21, 29, 36, 44, 51, 57, 63].includes(i);
return { x: 38 + col * 20, y: 44 + row * 20, supported };
});
return (
{countyTiles.map((tile, i) => (
Guilford County
COVERAGE MAP
County coverage
222,643
Parcels
{fieldRows.map(([label, pct]) => (
{label}
{pct}%
90 ? "#34C759" : "#2E6BF0" }} />
))}
{["Data date 6/24/2026", "48 fields", "Ready to buy"].map((label, i) => (
{label}
))}
);
}
function Coverage({ onBrowse }) {
return (
Check coverage before you buy
See what's live, when it was last refreshed, and how complete each field is. Tap any county for parcel counts and field-by-field coverage, then buy it or open it in the app.
View coverage
);
}
function Difference() {
const items = [
["2,170+ supported counties", "136M+ parcel records live today, with county-level counts before you buy.", "map"],
["One clean schema", "The same standardized fields in every supported county, so your pipeline never breaks.", "layers"],
["Refreshed and ready", "We pull from thousands of county sources and standardize them, so you skip the cleanup.", "list"],
];
const ico = (k) => {
const c = { fill: "none", stroke: GREEN_DK, strokeWidth: 2.2, strokeLinecap: "round", strokeLinejoin: "round" };
if (k === "map") return
;
if (k === "layers") return
;
return
;
};
return (
Why buy from LandAI
{items.map(([t, d, k], i) => (
))}
);
}
function ContactForm() {
const [inquiry, setInquiry] = useState("sales");
const [form, setForm] = useState({ name: "", email: "", phone: "", organization: "", title: "", subject: "", message: "", website: "" });
const [status, setStatus] = useState("idle");
const [error, setError] = useState("");
const setField = (key) => (event) => {
const value = event.target.value;
setForm(current => ({ ...current, [key]: value }));
setError("");
};
const validEmail = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(form.email.trim());
const canSubmit = form.name.trim() && validEmail && form.message.trim() && status !== "sending";
const inputStyle = {
width: "100%",
border: `1.5px solid ${BORDER}`,
borderRadius: 10,
background: "#fbfcfb",
color: INK,
fontSize: 15,
fontFamily: "inherit",
outline: "none",
boxSizing: "border-box",
};
const field = (key, label, req, tall, type = "text") => (
{label}{req && * }
{tall ? (
) : (
)}
);
const submit = async (event) => {
event.preventDefault();
if (!canSubmit) {
setError(validEmail ? "Please fill out the required fields." : "Please enter a valid email address.");
return;
}
setStatus("sending");
setError("");
try {
const response = await fetch("/api/contact", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
source: "data-store-landing",
inquiry,
name: form.name,
email: form.email,
phone: form.phone,
company: form.organization,
title: form.title,
subject: form.subject || "Data Store inquiry",
message: form.message,
page: window.location.href,
website: form.website,
}),
});
const contentType = response.headers.get("content-type") || "";
if (!contentType.includes("application/json")) {
throw new Error("Email endpoint is not available on this local server.");
}
const payload = await response.json().catch(() => ({}));
if (!response.ok) throw new Error(payload.error || "Message could not be sent.");
setStatus("sent");
} catch (err) {
setStatus("idle");
setError(`${err.message || "Message could not be sent."} You can also email john@landai.app directly.`);
}
};
return (
Not sure what you need? Ask before you buy.
Tell us what you're working on and we'll point you to the right county, format, or plan.
);
}
function SecondaryCTA() {
const goMobile = () => window.__landaiNav ? window.__landaiNav("mobile") : (location.href = "/");
const goApi = () => window.__landaiNav ? window.__landaiNav("api") : (location.href = "/api");
return (
Just looking up a parcel or two?
The LandAI mobile app is probably what you want.
Need the whole country or scheduled refreshes?
Talk to our team about bulk & API .
);
}
function FinalCTA({ onBrowse }) {
return (
Parcel data, ready when you are.
Shop the data store
);
}
function Footer() {
const cols = [
["Product", [["Mobile App", "mobile"], ["Data Store", "store"], ["Web app", "web"], ["Get the app", "app"]]],
["For", [["Hunters", "mobile"], ["Real estate", "mobile"], ["Landowners", "mobile"], ["Investors", "mobile"]]],
["Company", [["About", "about"], ["Contact", "contact"], ["Privacy", "privacy"], ["Terms", null]]],
];
const go = (t) => {
if (t === "mobile") return window.__landaiNav ? window.__landaiNav("mobile") : (location.href = "/");
if (t === "store") return window.__landaiNav ? window.__landaiNav("store") : (location.href = "/data-store");
if (t === "contact") return window.__landaiNav ? window.__landaiNav("contact") : (location.href = "/contact");
if (t === "about") return window.__landaiNav ? window.__landaiNav("about") : (location.href = "/about");
if (t === "privacy") return location.href = "/privacy";
if (t === "web") return openUrl(WEB_APP_URL);
if (t === "app") return window.__landaiGetApp && window.__landaiGetApp();
};
const mono = "'JetBrains Mono', monospace";
return (
Property intelligence for the people who actually walk the land.
{cols.map(([h, items], i) => (
{h}
{items.map(([label, t], j) => go(t) : undefined} style={{ color: INK, fontSize: 16.5, cursor: t ? "pointer" : "default" }}>{label} )}
))}
© 2026 LANDAI
BUILT IN NORTH CAROLINA
);
}
// ---------- BROWSE / PURCHASE SCREEN ----------
const STATES = ["Alabama","Alaska","Arizona","Arkansas","California","Colorado","Connecticut","Delaware","District of Columbia","Florida","Georgia","Guam","Hawaii","Idaho","Illinois","Indiana","Iowa","Kansas","Kentucky","Louisiana","Maine","Maryland","Massachusetts","Michigan","Minnesota","Mississippi","Missouri","Montana","Nebraska","Nevada","New Hampshire","New Jersey","New Mexico","New York","North Carolina","North Dakota","Northern Mariana Islands","Ohio","Oklahoma","Oregon","Pennsylvania","Puerto Rico","Rhode Island","South Carolina","South Dakota","Tennessee","Texas","U.S. Virgin Islands","Utah","Vermont","Virginia","Washington","West Virginia","Wisconsin","Wyoming"];
const STATS = [
["2,170", "Supported Counties"],
["136M", "Parcel Records"],
["133M", "Site Addresses"],
["116M", "Mailing Addresses"],
["121M", "Owner Names"],
];
function StatCard({ n, label, last }) {
return (
);
}
function DocButton({ children, onClick }) {
return (
{children}
);
}
const DATA_STORE_COUNTY_GEOJSON_URL = "https://raw.githubusercontent.com/plotly/datasets/master/geojson-counties-fips.json";
const DATA_STORE_COVERAGE_API_BASE = "https://us-central1-landai-476914.cloudfunctions.net/get_parcel";
const DATA_STORE_PUBLIC_COUNTIES_PATH = "/api/public/counties/all";
const DATA_STORE_AUTH_COUNTIES_PATH = "/api/counties/all";
const DATA_STORE_PUBLIC_FIELD_COVERAGE_PATH = countyFips => `/api/public/counties/${countyFips}/field-coverage`;
const DATA_STORE_COVERAGE_SOURCE_ID = "landai-store-coverage-counties";
const DATA_STORE_COVERAGE_FILL_LAYER_ID = "landai-store-coverage-counties-fill";
const DATA_STORE_COVERAGE_LINE_LAYER_ID = "landai-store-coverage-counties-line";
const DATA_STORE_COVERAGE_LABEL_LAYER_ID = "landai-store-coverage-counties-label";
const DATA_STORE_SELECTED_FILL_LAYER_ID = "landai-store-selected-county-fill";
const DATA_STORE_SELECTED_LINE_LAYER_ID = "landai-store-selected-county-line";
const DATA_STORE_STATE_OUTLINE_SOURCE_ID = "landai-store-selected-state-outline";
const DATA_STORE_STATE_OUTLINE_LAYER_ID = "landai-store-selected-state-outline-line";
const DATA_STORE_STATE_CLICK_ZOOM = 5.35;
const SUPPORTED_COUNTY_COMPLETE_COLOR = "#34C759";
const SUPPORTED_COUNTY_COMPLETE_OUTLINE_COLOR = "#166534";
const SUPPORTED_COUNTY_PREMIUM_COLOR = "#FF9500";
const SUPPORTED_COUNTY_PREMIUM_OUTLINE_COLOR = "#C76E00";
const SUPPORTED_COUNTY_COMPLETE_THRESHOLD_PCT = 40;
const SUPPORTED_COUNTY_SITE_COMPLETE_THRESHOLD_PCT = 5;
const SUPPORTED_COUNTY_PARTIAL_THRESHOLD_PCT = 10;
const DATA_STORE_FALLBACK_SUPPORTED_COUNTY_GEOIDS = ["01097", "37081", "37119", "16081", "56039", "12086"];
let dataStoreCoverageGeojsonPromise = null;
const dataStoreCountyFieldCoveragePromises = new Map();
function dataStoreFirstSymbolLayerId(map) {
try {
const layers = map.getStyle().layers || [];
const symbol = layers.find(layer => layer.type === "symbol");
return symbol && symbol.id;
} catch (_) {
return undefined;
}
}
function normalizeCountyCoverageStatus(value) {
const normalized = String(value || "").trim().toLowerCase();
if (["complete", "partial", "limited", "unknown", "premium"].includes(normalized)) return normalized;
if (normalized === "incomplete") return "limited";
return "";
}
function countyCoverageNumber(value) {
const numeric = Number(value);
return Number.isFinite(numeric) ? numeric : 0;
}
function countyCoveragePercent(count, total) {
if (!Number.isFinite(count) || !Number.isFinite(total) || total <= 0) return 0;
return Math.round((count / total) * 10000) / 100;
}
function clampCountyCoveragePercent(value) {
const numeric = Number(value);
if (!Number.isFinite(numeric)) return 0;
return Math.max(0, Math.min(100, numeric));
}
function countyCoverageStatusFromDetail(detail, supportedOverride = false) {
const fieldCoverage = detail && detail.field_coverage && typeof detail.field_coverage === "object"
? detail.field_coverage
: {};
const explicitStatus = normalizeCountyCoverageStatus(fieldCoverage.status || (detail && detail.coverage_status));
if (explicitStatus) return explicitStatus;
if (supportedOverride) return "complete";
const activeParcelCount = countyCoverageNumber(fieldCoverage.active_parcel_count || (detail && detail.active_parcel_count) || (detail && detail.parcel_count));
if (fieldCoverage.coverage_unknown === true || activeParcelCount <= 0) return "unknown";
const ownerNameCount = countyCoverageNumber(fieldCoverage.owner_name_count);
const mailingAddressCount = countyCoverageNumber(fieldCoverage.mailing_address_count);
const siteAddressCount = countyCoverageNumber(fieldCoverage.site_address_count);
const ownerNamePct = countyCoverageNumber(fieldCoverage.owner_name_pct)
|| countyCoveragePercent(ownerNameCount, activeParcelCount);
const mailingAddressPct = countyCoverageNumber(fieldCoverage.mailing_address_pct)
|| countyCoveragePercent(mailingAddressCount, activeParcelCount);
const siteAddressPct = countyCoverageNumber(fieldCoverage.site_address_pct)
|| countyCoveragePercent(siteAddressCount, activeParcelCount);
const ownerValue = clampCountyCoveragePercent(ownerNamePct);
const mailingValue = clampCountyCoveragePercent(mailingAddressPct);
const siteValue = clampCountyCoveragePercent(siteAddressPct);
if (
ownerValue >= SUPPORTED_COUNTY_COMPLETE_THRESHOLD_PCT
&& mailingValue >= SUPPORTED_COUNTY_COMPLETE_THRESHOLD_PCT
&& siteValue >= SUPPORTED_COUNTY_SITE_COMPLETE_THRESHOLD_PCT
) return "complete";
if (Math.max(ownerValue, mailingValue, siteValue) >= SUPPORTED_COUNTY_PARTIAL_THRESHOLD_PCT) return "partial";
return "limited";
}
function countyFipsFromFeature(feature) {
const raw = feature && (feature.id || feature.properties?.GEOID || feature.properties?.geoid || feature.properties?.FIPS || feature.properties?.fips);
const fips = String(raw || "").trim();
return fips ? fips.padStart(5, "0") : "";
}
function displayCountyNameForFeature(feature, stateName) {
const props = feature?.properties || {};
const rawName = props.COUNTY_NAME || props.NAME || props.name || "";
if (!stateName) return rawName;
const matched = countyNameForSlug(stateName, rawName);
return matched || rawName;
}
function escapeDataStoreMapHtml(value) {
return String(value || "")
.replace(/&/g, "&")
.replace(//g, ">")
.replace(/"/g, """)
.replace(/'/g, "'");
}
function dataStoreCountyTooltipHtml(countyName) {
return `
${escapeDataStoreMapHtml(countyName)}
`;
}
function dataStoreSearchKey(value) {
return String(value || "")
.trim()
.normalize("NFD")
.replace(/[\u0300-\u036f]/g, "")
.toLowerCase()
.replace(/&/g, " and ")
.replace(/u\.s\./g, "us")
.replace(/[^a-z0-9]+/g, " ")
.trim()
.replace(/\s+/g, " ");
}
function dataStoreCountyBaseName(countyName) {
return String(countyName || "")
.replace(/\s+(county|parish|borough|municipality|census area|municipio)$/i, "")
.trim();
}
function dataStoreSearchLabelForCounty(countyName, stateName) {
const stateCode = (stateCodeForName(stateName) || "").toUpperCase();
return stateCode ? `${countyName}, ${stateCode}` : countyName;
}
function dataStoreSuggestionScore(key, haystacks) {
let best = 0;
haystacks.forEach(value => {
const haystack = dataStoreSearchKey(value);
if (!haystack) return;
if (haystack === key) best = Math.max(best, 100);
else if (haystack.startsWith(key)) best = Math.max(best, 82);
else if (haystack.includes(key)) best = Math.max(best, 64);
});
return best;
}
function dataStoreLocalSearchSuggestions(query, limit = 8) {
const key = dataStoreSearchKey(query);
if (!key) return [];
const results = [];
STATES.forEach((stateName, stateIndex) => {
const stateCode = stateCodeForName(stateName);
const score = dataStoreSuggestionScore(key, [stateName, stateCode]);
if (score) {
results.push({
type: "state",
label: stateName,
detail: "State",
stateName,
score,
rank: stateIndex,
});
}
});
Object.entries(COUNTIES_BY_STATE).forEach(([stateName, counties], stateIndex) => {
const stateCode = stateCodeForName(stateName);
counties.forEach((countyName, countyIndex) => {
const baseName = dataStoreCountyBaseName(countyName);
const score = dataStoreSuggestionScore(key, [
countyName,
baseName,
`${countyName} ${stateName}`,
`${baseName} ${stateName}`,
`${countyName} ${stateCode}`,
`${baseName} ${stateCode}`,
`${stateName} ${countyName}`,
`${stateCode} ${baseName}`,
]);
if (score) {
results.push({
type: "county",
label: dataStoreSearchLabelForCounty(countyName, stateName),
detail: stateName,
stateName,
countyName,
score,
rank: 100 + stateIndex * 1000 + countyIndex,
});
}
});
});
return results
.sort((a, b) => (b.score - a.score) || (a.rank - b.rank) || a.label.localeCompare(b.label))
.slice(0, limit);
}
function dataStoreBestLocalSearchResult(query) {
const key = dataStoreSearchKey(query);
if (key.length < 2) return null;
const suggestions = dataStoreLocalSearchSuggestions(query, 1);
const best = suggestions[0];
if (!best) return null;
if (best.score >= 100) return best;
return key.length >= 3 && best.score >= 82 ? best : null;
}
function dataStorePointInRing(point, ring) {
if (!Array.isArray(ring) || ring.length < 4) return false;
const x = Number(point[0]);
const y = Number(point[1]);
let inside = false;
for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
const xi = Number(ring[i]?.[0]);
const yi = Number(ring[i]?.[1]);
const xj = Number(ring[j]?.[0]);
const yj = Number(ring[j]?.[1]);
if (![xi, yi, xj, yj].every(Number.isFinite)) continue;
const intersects = ((yi > y) !== (yj > y)) && (x < ((xj - xi) * (y - yi)) / (yj - yi || Number.EPSILON) + xi);
if (intersects) inside = !inside;
}
return inside;
}
function dataStorePointInPolygon(point, rings) {
if (!Array.isArray(rings) || !rings.length) return false;
if (!dataStorePointInRing(point, rings[0])) return false;
for (let i = 1; i < rings.length; i += 1) {
if (dataStorePointInRing(point, rings[i])) return false;
}
return true;
}
function dataStoreFeatureContainsPoint(feature, point) {
const geometry = feature?.geometry;
if (!geometry) return false;
if (geometry.type === "Polygon") return dataStorePointInPolygon(point, geometry.coordinates);
if (geometry.type === "MultiPolygon") {
return (geometry.coordinates || []).some(polygon => dataStorePointInPolygon(point, polygon));
}
return false;
}
function dataStoreVisitCoordinates(coordinates, visit) {
if (!Array.isArray(coordinates)) return;
if (typeof coordinates[0] === "number" && typeof coordinates[1] === "number") {
visit(coordinates);
return;
}
coordinates.forEach(part => dataStoreVisitCoordinates(part, visit));
}
function dataStoreFeatureBounds(feature) {
let minLng = Infinity;
let minLat = Infinity;
let maxLng = -Infinity;
let maxLat = -Infinity;
dataStoreVisitCoordinates(feature?.geometry?.coordinates, ([lng, lat]) => {
const x = Number(lng);
const y = Number(lat);
if (!Number.isFinite(x) || !Number.isFinite(y)) return;
minLng = Math.min(minLng, x);
minLat = Math.min(minLat, y);
maxLng = Math.max(maxLng, x);
maxLat = Math.max(maxLat, y);
});
if (![minLng, minLat, maxLng, maxLat].every(Number.isFinite)) return null;
return [[minLng, minLat], [maxLng, maxLat]];
}
function dataStoreLongitudeBounds(longitudes) {
const normalized = (longitudes || [])
.map(value => Number(value))
.filter(Number.isFinite)
.map(value => ((value % 360) + 360) % 360)
.sort((a, b) => a - b);
if (!normalized.length) return null;
if (normalized.length === 1) {
const lng = normalized[0] > 180 ? normalized[0] - 360 : normalized[0];
return [lng, lng];
}
let largestGap = -Infinity;
let gapIndex = 0;
for (let i = 0; i < normalized.length; i += 1) {
const current = normalized[i];
const next = i === normalized.length - 1 ? normalized[0] + 360 : normalized[i + 1];
const gap = next - current;
if (gap > largestGap) {
largestGap = gap;
gapIndex = i;
}
}
const start = normalized[(gapIndex + 1) % normalized.length];
const span = Math.max(0, 360 - largestGap);
const west = start > 180 ? start - 360 : start;
return [west, west + span];
}
function dataStoreMergedBounds(features) {
const longitudes = [];
let minLat = Infinity;
let maxLat = -Infinity;
(features || []).forEach(feature => {
dataStoreVisitCoordinates(feature?.geometry?.coordinates, ([lng, lat]) => {
const x = Number(lng);
const y = Number(lat);
if (!Number.isFinite(x) || !Number.isFinite(y)) return;
longitudes.push(x);
minLat = Math.min(minLat, y);
maxLat = Math.max(maxLat, y);
});
});
const lngBounds = dataStoreLongitudeBounds(longitudes);
if (!lngBounds || ![minLat, maxLat].every(Number.isFinite)) return null;
return [[lngBounds[0], minLat], [lngBounds[1], maxLat]];
}
function dataStoreStateFeatures(geojson, stateName) {
const wanted = slugify(stateName);
if (!wanted) return [];
return (geojson?.features || []).filter(feature => {
const fips = countyFipsFromFeature(feature);
const featureStateName = stateNameForCountyFips(fips) || feature?.properties?.STATE_NAME || "";
return slugify(featureStateName) === wanted;
});
}
function dataStoreStateBounds(geojson, stateName) {
const features = dataStoreStateFeatures(geojson, stateName);
return dataStoreMergedBounds(features);
}
function dataStoreCoordinateKey(coord) {
const lng = Number(coord?.[0]);
const lat = Number(coord?.[1]);
if (!Number.isFinite(lng) || !Number.isFinite(lat)) return "";
return `${lng.toFixed(6)},${lat.toFixed(6)}`;
}
function dataStoreAddBoundaryRingSegments(ring, segments) {
if (!Array.isArray(ring) || ring.length < 2) return;
for (let i = 0; i < ring.length; i += 1) {
const a = ring[i];
const b = ring[(i + 1) % ring.length];
const aKey = dataStoreCoordinateKey(a);
const bKey = dataStoreCoordinateKey(b);
if (!aKey || !bKey || aKey === bKey) continue;
const key = aKey < bKey ? `${aKey}|${bKey}` : `${bKey}|${aKey}`;
const existing = segments.get(key);
if (existing) existing.count += 1;
else segments.set(key, { count: 1, coordinates: [[Number(a[0]), Number(a[1])], [Number(b[0]), Number(b[1])]] });
}
}
function dataStoreAddBoundaryGeometrySegments(geometry, segments) {
if (geometry?.type === "Polygon") {
(geometry.coordinates || []).forEach(ring => dataStoreAddBoundaryRingSegments(ring, segments));
} else if (geometry?.type === "MultiPolygon") {
(geometry.coordinates || []).forEach(polygon => {
(polygon || []).forEach(ring => dataStoreAddBoundaryRingSegments(ring, segments));
});
}
}
function dataStoreStateOutlineGeoJSON(geojson, stateName) {
const segments = new Map();
dataStoreStateFeatures(geojson, stateName).forEach(feature => dataStoreAddBoundaryGeometrySegments(feature?.geometry, segments));
return {
type: "FeatureCollection",
features: Array.from(segments.values())
.filter(segment => segment.count === 1)
.map((segment, index) => ({
type: "Feature",
id: `state-outline-${index}`,
properties: { STATE_NAME: stateName },
geometry: { type: "LineString", coordinates: segment.coordinates },
})),
};
}
function dataStoreSetStateOutlineOnMap(map, geojson, stateName) {
if (!map || !map.getStyle) return;
const outline = dataStoreStateOutlineGeoJSON(geojson, stateName);
if (map.getSource(DATA_STORE_STATE_OUTLINE_SOURCE_ID)) {
map.getSource(DATA_STORE_STATE_OUTLINE_SOURCE_ID).setData(outline);
} else {
map.addSource(DATA_STORE_STATE_OUTLINE_SOURCE_ID, {
type: "geojson",
data: outline,
tolerance: 0.2,
});
}
if (!map.getLayer(DATA_STORE_STATE_OUTLINE_LAYER_ID)) {
const before = map.getLayer(DATA_STORE_COVERAGE_LABEL_LAYER_ID) ? DATA_STORE_COVERAGE_LABEL_LAYER_ID : undefined;
map.addLayer({
id: DATA_STORE_STATE_OUTLINE_LAYER_ID,
type: "line",
source: DATA_STORE_STATE_OUTLINE_SOURCE_ID,
layout: {
"line-cap": "round",
"line-join": "round",
},
paint: {
"line-color": "#050505",
"line-opacity": 0.92,
"line-width": ["interpolate", ["linear"], ["zoom"], 2, 1.6, 5, 2.4, 8, 3.8, 11, 5],
"line-blur": 0.15,
},
}, before);
}
}
function dataStoreFeatureSvgPath(feature, size = 40, padding = 7) {
const bounds = dataStoreFeatureBounds(feature);
if (!bounds) return "";
const [[minLng, minLat], [maxLng, maxLat]] = bounds;
const lngSpan = Math.max(maxLng - minLng, 1e-9);
const latSpan = Math.max(maxLat - minLat, 1e-9);
const usable = Math.max(size - padding * 2, 1);
const pointPath = ([lng, lat]) => {
const x = padding + ((Number(lng) - minLng) / lngSpan) * usable;
const y = size - padding - ((Number(lat) - minLat) / latSpan) * usable;
return `${Number.isFinite(x) ? x.toFixed(1) : padding} ${Number.isFinite(y) ? y.toFixed(1) : padding}`;
};
const ringPath = ring => {
if (!Array.isArray(ring) || ring.length < 3) return "";
const points = ring.map(pointPath).join(" L ");
return points ? `M ${points} Z` : "";
};
const polygonPath = polygon => (Array.isArray(polygon) ? polygon.map(ringPath).filter(Boolean).join(" ") : "");
const geometry = feature?.geometry;
if (geometry?.type === "Polygon") return polygonPath(geometry.coordinates);
if (geometry?.type === "MultiPolygon") return (geometry.coordinates || []).map(polygonPath).filter(Boolean).join(" ");
return "";
}
function dataStoreFeatureMatchesCounty(feature, countyName, stateName) {
const fips = countyFipsFromFeature(feature);
const featureStateName = stateNameForCountyFips(fips) || feature?.properties?.STATE_NAME || "";
if (stateName && slugify(featureStateName) !== slugify(stateName)) return false;
const featureCountyName = displayCountyNameForFeature(feature, featureStateName);
return countySlug(featureCountyName) === countySlug(countyName) || slugify(featureCountyName) === slugify(countyName);
}
async function dataStoreFeatureForCounty(countyName, stateName) {
const geojson = await loadDataStoreCoverageGeoJSON();
return (geojson?.features || []).find(feature => dataStoreFeatureMatchesCounty(feature, countyName, stateName)) || null;
}
function dataStoreSelectedFilterForFeature(feature) {
const fips = countyFipsFromFeature(feature);
return fips ? ["==", ["get", "GEOID"], fips] : ["==", ["get", "GEOID"], "__none__"];
}
function dataStoreSetSelectedCountyOnMap(map, feature) {
if (!map || !feature) return;
const filter = dataStoreSelectedFilterForFeature(feature);
[DATA_STORE_SELECTED_FILL_LAYER_ID, DATA_STORE_SELECTED_LINE_LAYER_ID].forEach(layerId => {
if (map.getLayer(layerId)) map.setFilter(layerId, filter);
});
}
function dataStoreFitMapToFeature(map, feature, duration = 850) {
const bounds = dataStoreFeatureBounds(feature);
if (!map || !bounds) return;
map.fitBounds(bounds, {
duration,
maxZoom: 10.4,
padding: { top: 96, right: 80, bottom: 76, left: 80 },
});
}
async function dataStoreFitMapToState(map, stateName, duration = 850) {
if (!map || !stateName) return false;
const geojson = await loadDataStoreCoverageGeoJSON();
const bounds = dataStoreStateBounds(geojson, stateName);
if (!bounds) return false;
map.fitBounds(bounds, {
duration,
maxZoom: 7.35,
padding: { top: 116, right: 86, bottom: 66, left: 86 },
});
return true;
}
function dataStoreCountySearchResultForFeature(feature) {
const fips = countyFipsFromFeature(feature);
const stateName = stateNameForCountyFips(fips) || feature?.properties?.STATE_NAME || "";
const countyName = displayCountyNameForFeature(feature, stateName);
if (!stateName || !countyName) return null;
return {
type: "county",
label: dataStoreSearchLabelForCounty(countyName, stateName),
detail: stateName,
stateName,
countyName,
};
}
function dataStoreMetadataText(value) {
return String(value || "").trim();
}
function dataStoreMetadataCount(value) {
const numeric = Number(value);
return Number.isFinite(numeric) && numeric > 0 ? Math.round(numeric) : 0;
}
function dataStoreCountyMetadataFromFeature(feature) {
const props = feature?.properties || {};
return {
parcelCount: dataStoreMetadataCount(props.LANDAI_ACTIVE_PARCEL_COUNT || props.LANDAI_PARCEL_COUNT),
sourceUpdatedAt: dataStoreMetadataText(props.LANDAI_SOURCE_UPDATED_AT),
sourceDataAsOf: dataStoreMetadataText(props.LANDAI_SOURCE_DATA_AS_OF),
sourceDataAsOfPrecision: dataStoreMetadataText(props.LANDAI_SOURCE_DATA_AS_OF_PRECISION),
sourceDataAsOfLabel: dataStoreMetadataText(props.LANDAI_SOURCE_DATA_AS_OF_LABEL),
latestIngestedAt: dataStoreMetadataText(props.LANDAI_LATEST_INGESTED_AT),
};
}
function dataStoreFormattedDateOnly(value) {
const raw = dataStoreMetadataText(value);
if (!raw) return "";
if (/^\d{11,}$/.test(raw)) {
const parsed = Number(raw);
if (Number.isFinite(parsed)) return new Date(parsed).toLocaleDateString(undefined, { timeZone: "UTC" });
}
if (/^\d{10}$/.test(raw)) {
const parsed = Number(raw) * 1000;
if (Number.isFinite(parsed)) return new Date(parsed).toLocaleDateString(undefined, { timeZone: "UTC" });
}
const dateOnly = raw.match(/^(\d{4})-(\d{2})-(\d{2})/);
if (dateOnly) {
const parsed = Date.parse(`${dateOnly[1]}-${dateOnly[2]}-${dateOnly[3]}T00:00:00Z`);
if (!Number.isNaN(parsed)) return new Date(parsed).toLocaleDateString(undefined, { timeZone: "UTC" });
}
const parsed = Date.parse(raw);
if (!Number.isNaN(parsed)) return new Date(parsed).toLocaleDateString();
return raw;
}
function dataStoreFormattedSourceVintage(value, precision) {
const raw = dataStoreMetadataText(value);
const cleanPrecision = dataStoreMetadataText(precision).toLowerCase();
if (!raw) return "";
if (cleanPrecision === "quarter") {
const match = raw.match(/^(\d{4})[-\s]?Q([1-4])$/i) || raw.match(/^Q([1-4])\s*(\d{4})$/i);
if (match) {
const year = match[1].length === 4 ? match[1] : match[2];
const quarter = match[1].length === 4 ? match[2] : match[1];
return `Q${quarter} ${year}`;
}
}
if (cleanPrecision === "month" && /^\d{4}-\d{2}$/.test(raw)) {
const parsed = Date.parse(`${raw}-01T00:00:00Z`);
if (!Number.isNaN(parsed)) {
return new Date(parsed).toLocaleDateString(undefined, { month: "long", year: "numeric", timeZone: "UTC" });
}
}
if (cleanPrecision === "year" && /^\d{4}$/.test(raw)) return raw;
return dataStoreFormattedDateOnly(raw);
}
function dataStoreDateFromLabel(value) {
const raw = dataStoreMetadataText(value);
if (!raw) return "";
const isoDate = raw.match(/\b\d{4}-\d{2}-\d{2}\b/);
if (isoDate) return dataStoreFormattedDateOnly(isoDate[0]);
const slashDate = raw.match(/\b\d{1,2}\/\d{1,2}\/\d{2,4}\b/);
if (slashDate) return dataStoreFormattedDateOnly(slashDate[0]);
const year = raw.match(/\b(19|20)\d{2}\b/);
return year ? year[0] : "";
}
function dataStoreCountyDataDateLabel(meta, loading = false) {
if (loading) return "Loading...";
if (!meta) return "Unknown";
if (meta.sourceUpdatedAt) return dataStoreFormattedDateOnly(meta.sourceUpdatedAt);
if (meta.sourceDataAsOf) return dataStoreFormattedSourceVintage(meta.sourceDataAsOf, meta.sourceDataAsOfPrecision);
if (meta.sourceDataAsOfLabel) {
const labelDate = dataStoreDateFromLabel(meta.sourceDataAsOfLabel);
if (labelDate) return labelDate;
}
if (meta.latestIngestedAt) return dataStoreFormattedDateOnly(meta.latestIngestedAt);
return "Unknown";
}
function dataStoreCountyParcelCountLabel(meta, loading = false) {
if (loading) return "Loading...";
if (meta?.parcelCount) return meta.parcelCount.toLocaleString();
return "Unknown";
}
function dataStoreCountyIsSupported(feature) {
const props = feature?.properties || {};
return props.LANDAI_MAP_CLASS === "landai" || props.LANDAI_SUPPORTED === true;
}
async function dataStoreCountySearchResultForLngLat(lng, lat) {
const geojson = await loadDataStoreCoverageGeoJSON();
const point = [Number(lng), Number(lat)];
if (!point.every(Number.isFinite)) return null;
const feature = (geojson?.features || []).find(candidate => dataStoreFeatureContainsPoint(candidate, point));
return feature ? dataStoreCountySearchResultForFeature(feature) : null;
}
async function dataStoreMapboxGeocodeFeatures(query, options = {}) {
const token = String(window.MAPBOX_ACCESS_TOKEN || "").trim();
if (!token) throw new Error("Missing Mapbox token");
const params = new URLSearchParams({
access_token: token,
country: "us",
limit: String(options.limit || 5),
types: options.types || "place,locality,neighborhood,address,poi,postcode,district,region",
});
const url = `https://api.mapbox.com/geocoding/v5/mapbox.places/${encodeURIComponent(query)}.json?${params.toString()}`;
const response = await fetch(url);
if (!response.ok) throw new Error(`Mapbox geocoding ${response.status}`);
const payload = await response.json();
return Array.isArray(payload?.features) ? payload.features : [];
}
function dataStoreMapboxRegionName(feature) {
const region = (feature?.context || []).find(item => String(item?.id || "").startsWith("region."));
return region?.text || "";
}
function dataStoreMapboxPlaceTypeLabel(feature) {
const types = Array.isArray(feature?.place_type) ? feature.place_type : [];
if (types.includes("place") || types.includes("locality")) return "City";
if (types.includes("neighborhood")) return "Neighborhood";
if (types.includes("district")) return "Area";
if (types.includes("region")) return "State";
if (types.includes("postcode")) return "ZIP";
if (types.includes("address")) return "Address";
return "Place";
}
async function dataStoreMapboxPlaceSuggestions(query, limit = 5) {
const key = dataStoreSearchKey(query);
if (key.length < 3) return [];
const features = await dataStoreMapboxGeocodeFeatures(query, {
limit,
types: "place,locality,neighborhood,district,region",
});
return features.map((feature, index) => {
const center = Array.isArray(feature?.center) ? feature.center : [];
const regionName = dataStoreMapboxRegionName(feature);
const typeLabel = dataStoreMapboxPlaceTypeLabel(feature);
const label = feature?.text || feature?.place_name || "";
if (!label || center.length < 2) return null;
return {
type: "place",
id: feature?.id || `${label}-${center.join(",")}-${index}`,
label,
detail: regionName ? `${typeLabel}, ${regionName}` : typeLabel,
placeName: feature?.place_name || label,
center,
};
}).filter(Boolean);
}
async function dataStoreMapboxCountySearch(query) {
const features = await dataStoreMapboxGeocodeFeatures(query);
for (const feature of features) {
const center = Array.isArray(feature?.center) ? feature.center : null;
if (!center || center.length < 2) continue;
const match = await dataStoreCountySearchResultForLngLat(center[0], center[1]);
if (match) return match;
}
return null;
}
function stateNameForCountyFips(fips) {
return STATE_FIPS_TO_NAME[String(fips || "").slice(0, 2)] || "";
}
function buildDataStoreCoverageGeoJSON(countyGeojson, registry) {
const detailsByFips = registry.detailsByFips || new Map();
const supportedGeoids = registry.supportedGeoids || new Set();
const features = Array.isArray(countyGeojson?.features)
? countyGeojson.features.map(feature => {
const fips = countyFipsFromFeature(feature);
if (!fips || !feature.geometry) return null;
const isSupportedByList = supportedGeoids.has(fips);
const detail = detailsByFips.get(fips) || (isSupportedByList ? { county_fips: fips, coverage_status: "complete" } : null);
const coverageStatus = detail ? countyCoverageStatusFromDetail(detail, isSupportedByList) : "premium";
const mapClass = coverageStatus === "complete" ? "landai" : "premium";
const countyName = (detail && detail.county_name) || feature.properties?.COUNTY_NAME || feature.properties?.NAME || "";
const stateName = stateNameForCountyFips(fips);
const fieldCoverage = detail && detail.field_coverage && typeof detail.field_coverage === "object" ? detail.field_coverage : {};
const sourceUpdatedAt = dataStoreMetadataText((detail && detail.source_updated_at) || fieldCoverage.source_updated_at);
const sourceDataAsOf = dataStoreMetadataText((detail && detail.source_data_as_of) || fieldCoverage.source_data_as_of);
const sourceDataAsOfPrecision = dataStoreMetadataText((detail && detail.source_data_as_of_precision) || fieldCoverage.source_data_as_of_precision);
const sourceDataAsOfLabel = dataStoreMetadataText((detail && detail.source_data_as_of_label) || fieldCoverage.source_data_as_of_label);
const latestIngestedAt = dataStoreMetadataText((detail && detail.latest_ingested_at) || fieldCoverage.latest_ingested_at);
const coverageRefreshedAt = dataStoreMetadataText((detail && detail.coverage_refreshed_at) || fieldCoverage.refreshed_at);
const activeParcelCount = dataStoreMetadataCount(fieldCoverage.active_parcel_count || (detail && detail.active_parcel_count) || (detail && detail.parcel_count));
return {
...feature,
id: fips,
properties: {
...(feature.properties || {}),
GEOID: fips,
STATE_FIPS: fips.slice(0, 2),
STATE_NAME: stateName,
COUNTY_NAME: countyName,
LANDAI_MAP_CLASS: mapClass,
LANDAI_COVERAGE_STATUS: mapClass === "landai" ? "complete" : "premium",
LANDAI_RAW_STATUS: coverageStatus,
LANDAI_SUPPORTED: mapClass === "landai",
LANDAI_ACTIVE_PARCEL_COUNT: activeParcelCount,
LANDAI_PARCEL_COUNT: activeParcelCount,
LANDAI_SOURCE_UPDATED_AT: sourceUpdatedAt,
LANDAI_SOURCE_DATA_AS_OF: sourceDataAsOf,
LANDAI_SOURCE_DATA_AS_OF_PRECISION: sourceDataAsOfPrecision,
LANDAI_SOURCE_DATA_AS_OF_LABEL: sourceDataAsOfLabel,
LANDAI_LATEST_INGESTED_AT: latestIngestedAt,
LANDAI_COVERAGE_REFRESHED_AT: coverageRefreshedAt,
},
};
}).filter(Boolean)
: [];
return { type: "FeatureCollection", features };
}
function loadDataStoreCoverageGeoJSON() {
if (dataStoreCoverageGeojsonPromise) return dataStoreCoverageGeojsonPromise;
const apiBase = String(window.LANDAI_COVERAGE_API_BASE || window.LANDAI_API_BASE_URL || DATA_STORE_COVERAGE_API_BASE).replace(/\/$/, "");
dataStoreCoverageGeojsonPromise = Promise.all([
fetch(DATA_STORE_COUNTY_GEOJSON_URL).then(res => {
if (!res.ok) throw new Error(`County geometry ${res.status}`);
return res.json();
}),
fetch(`${apiBase}${DATA_STORE_PUBLIC_COUNTIES_PATH}`)
.then(res => {
if (!res.ok) throw new Error(`Public county registry ${res.status}`);
return res.json();
})
.catch(publicErr => {
console.warn("[data-store-map] Public county registry unavailable; trying authenticated county registry", publicErr);
return fetch(`${apiBase}${DATA_STORE_AUTH_COUNTIES_PATH}`)
.then(res => {
if (!res.ok) throw new Error(`County registry ${res.status}`);
return res.json();
})
.catch(authErr => {
console.warn("[data-store-map] County registry unavailable; loading static supported-county catalog", authErr);
return fetch("/supported-counties.json")
.then(res => {
if (!res.ok) throw new Error(`Static supported counties ${res.status}`);
return res.json();
})
.catch(staticErr => {
console.warn("[data-store-map] Static supported-county catalog unavailable; using minimal fallback", staticErr);
return { geoids: DATA_STORE_FALLBACK_SUPPORTED_COUNTY_GEOIDS };
});
});
}),
]).then(([countyGeojson, registryData]) => {
const countyDetails = Array.isArray(registryData.counties) ? registryData.counties : [];
const detailsByFips = new Map(
countyDetails
.map(county => [String(county?.county_fips || "").trim().padStart(5, "0"), county])
.filter(([fips]) => fips && fips !== "00000"),
);
const supportedGeoids = new Set(
(Array.isArray(registryData.geoids) ? registryData.geoids : [])
.map(fips => String(fips || "").trim().padStart(5, "0"))
.filter(fips => fips && fips !== "00000"),
);
return buildDataStoreCoverageGeoJSON(countyGeojson, { detailsByFips, supportedGeoids });
}).catch(err => {
dataStoreCoverageGeojsonPromise = null;
throw err;
});
return dataStoreCoverageGeojsonPromise;
}
function loadDataStoreCountyFieldCoverage(countyFips) {
const fips = String(countyFips || "").replace(/\D/g, "").padStart(5, "0");
if (!/^\d{5}$/.test(fips)) return Promise.resolve(null);
if (dataStoreCountyFieldCoveragePromises.has(fips)) return dataStoreCountyFieldCoveragePromises.get(fips);
const apiBase = String(window.LANDAI_COVERAGE_API_BASE || window.LANDAI_API_BASE_URL || DATA_STORE_COVERAGE_API_BASE).replace(/\/$/, "");
const promise = fetch(`${apiBase}${DATA_STORE_PUBLIC_FIELD_COVERAGE_PATH(fips)}`)
.then(res => {
if (res.status === 404) return null;
if (!res.ok) throw new Error(`County field coverage ${res.status}`);
return res.json();
})
.then(payload => {
const fields = Array.isArray(payload?.fields) ? payload.fields : [];
return { ...(payload || {}), county_fips: fips, fields };
})
.catch(err => {
dataStoreCountyFieldCoveragePromises.delete(fips);
throw err;
});
dataStoreCountyFieldCoveragePromises.set(fips, promise);
return promise;
}
function useDataStoreCountyData(countyName, stateName) {
const [countyMeta, setCountyMeta] = useState(null);
const [countyMetaLoading, setCountyMetaLoading] = useState(true);
const [fieldCoverage, setFieldCoverage] = useState(null);
const [fieldCoverageLoading, setFieldCoverageLoading] = useState(true);
useEffect(() => {
let cancelled = false;
setCountyMetaLoading(true);
setFieldCoverageLoading(true);
setCountyMeta(null);
setFieldCoverage(null);
dataStoreFeatureForCounty(countyName, stateName)
.then(feature => {
if (cancelled) return null;
setCountyMeta(feature ? dataStoreCountyMetadataFromFeature(feature) : null);
const fips = countyFipsFromFeature(feature);
if (!fips) return null;
return loadDataStoreCountyFieldCoverage(fips);
})
.then(coverage => {
if (!cancelled) setFieldCoverage(coverage || null);
})
.catch(err => {
if (!cancelled) {
setCountyMeta(null);
setFieldCoverage(null);
}
console.warn("[data-store-map] County field metadata unavailable", err);
})
.finally(() => {
if (!cancelled) {
setCountyMetaLoading(false);
setFieldCoverageLoading(false);
}
});
return () => {
cancelled = true;
};
}, [countyName, stateName]);
return { countyMeta, countyMetaLoading, fieldCoverage, fieldCoverageLoading };
}
function useSupportedCountiesInState(stateName, currentCounty) {
const [state, setState] = useState({ loading: true, counties: [] });
useEffect(() => {
let cancelled = false;
setState({ loading: true, counties: [] });
loadDataStoreCoverageGeoJSON()
.then(geojson => {
if (cancelled) return;
const currentSlug = countySlug(currentCounty);
const seen = new Set();
const counties = [];
(geojson?.features || []).forEach(feature => {
const fips = countyFipsFromFeature(feature);
const featureStateName = stateNameForCountyFips(fips) || feature?.properties?.STATE_NAME || "";
if (slugify(featureStateName) !== slugify(stateName)) return;
if (!dataStoreCountyIsSupported(feature)) return;
const name = displayCountyNameForFeature(feature, stateName);
const slug = countySlug(name);
if (!name || !slug || slug === currentSlug || seen.has(slug)) return;
seen.add(slug);
counties.push(name);
});
counties.sort((a, b) => a.localeCompare(b));
setState({ loading: false, counties });
})
.catch(err => {
if (!cancelled) setState({ loading: false, counties: [] });
console.warn("[data-store-state] Supported county list unavailable", err);
});
return () => {
cancelled = true;
};
}, [stateName, currentCounty]);
return state;
}
function addDataStoreCoverageOverlay(map) {
return loadDataStoreCoverageGeoJSON().then(geojson => {
if (!map || !map.getStyle) return;
const before = dataStoreFirstSymbolLayerId(map);
if (map.getSource(DATA_STORE_COVERAGE_SOURCE_ID)) {
map.getSource(DATA_STORE_COVERAGE_SOURCE_ID).setData(geojson);
return geojson;
}
map.addSource(DATA_STORE_COVERAGE_SOURCE_ID, {
type: "geojson",
data: geojson,
tolerance: 0.55,
});
map.addLayer({
id: DATA_STORE_COVERAGE_FILL_LAYER_ID,
type: "fill",
source: DATA_STORE_COVERAGE_SOURCE_ID,
paint: {
"fill-color": [
"case",
["==", ["get", "LANDAI_MAP_CLASS"], "landai"],
SUPPORTED_COUNTY_COMPLETE_COLOR,
SUPPORTED_COUNTY_PREMIUM_COLOR,
],
"fill-opacity": [
"case",
["==", ["get", "LANDAI_MAP_CLASS"], "landai"],
0.68,
0.46,
],
},
}, before || undefined);
map.addLayer({
id: DATA_STORE_COVERAGE_LINE_LAYER_ID,
type: "line",
source: DATA_STORE_COVERAGE_SOURCE_ID,
paint: {
"line-color": [
"case",
["==", ["get", "LANDAI_MAP_CLASS"], "landai"],
SUPPORTED_COUNTY_COMPLETE_OUTLINE_COLOR,
SUPPORTED_COUNTY_PREMIUM_OUTLINE_COLOR,
],
"line-opacity": 0.76,
"line-width": ["interpolate", ["linear"], ["zoom"], 2, 0.24, 5, 0.52, 8, 0.9, 11, 1.3],
},
}, before || undefined);
map.addLayer({
id: DATA_STORE_SELECTED_FILL_LAYER_ID,
type: "fill",
source: DATA_STORE_COVERAGE_SOURCE_ID,
filter: ["==", ["get", "GEOID"], "__none__"],
paint: {
"fill-color": "#2E6BF0",
"fill-opacity": 0.26,
},
}, before || undefined);
map.addLayer({
id: DATA_STORE_SELECTED_LINE_LAYER_ID,
type: "line",
source: DATA_STORE_COVERAGE_SOURCE_ID,
filter: ["==", ["get", "GEOID"], "__none__"],
paint: {
"line-color": "#0E47D9",
"line-opacity": 0.95,
"line-width": ["interpolate", ["linear"], ["zoom"], 4, 2.4, 8, 3.6, 12, 5],
},
}, before || undefined);
map.addLayer({
id: DATA_STORE_COVERAGE_LABEL_LAYER_ID,
type: "symbol",
source: DATA_STORE_COVERAGE_SOURCE_ID,
minzoom: 5.6,
layout: {
"text-field": ["get", "COUNTY_NAME"],
"text-size": ["interpolate", ["linear"], ["zoom"], 6, 9.5, 9, 11.5, 12, 13],
"text-padding": 3,
"text-optional": true,
},
paint: {
"text-color": "#1b2a24",
"text-halo-color": "#ffffff",
"text-halo-width": 1.15,
"text-opacity": ["interpolate", ["linear"], ["zoom"], 5.6, 0, 6.5, 0.92],
},
}, before || undefined);
return geojson;
});
}
function BrowseMapboxMap({ onCounty, selectedCounty }) {
const mapNode = useRef(null);
const mapRef = useRef(null);
const onCountyRef = useRef(onCounty);
const selectedCountyRef = useRef(selectedCounty || null);
const stateDrilldownRef = useRef("");
const [status, setStatus] = useState("loading");
useEffect(() => {
onCountyRef.current = onCounty;
}, [onCounty]);
useEffect(() => {
selectedCountyRef.current = selectedCounty || null;
}, [selectedCounty?.countyName, selectedCounty?.stateName]);
useEffect(() => {
const map = mapRef.current;
if (!map || status !== "ready") return undefined;
if (!selectedCounty) {
stateDrilldownRef.current = "";
[DATA_STORE_SELECTED_FILL_LAYER_ID, DATA_STORE_SELECTED_LINE_LAYER_ID].forEach(layerId => {
if (map.getLayer(layerId)) map.setFilter(layerId, ["==", ["get", "GEOID"], "__none__"]);
});
map.fitBounds(
[
[-125.25, 24.35],
[-66.5, 49.85],
],
{ duration: 650, padding: { top: 108, right: 38, bottom: 34, left: 38 } },
);
return undefined;
}
let cancelled = false;
dataStoreFeatureForCounty(selectedCounty.countyName, selectedCounty.stateName)
.then(feature => {
if (cancelled || !feature) return;
dataStoreSetSelectedCountyOnMap(map, feature);
dataStoreFitMapToFeature(map, feature);
})
.catch(err => console.warn("[data-store-map] Selected county zoom failed", err));
return () => {
cancelled = true;
};
}, [status, selectedCounty?.countyName, selectedCounty?.stateName]);
useEffect(() => {
const node = mapNode.current;
if (!node || mapRef.current) return undefined;
const mapboxgl = window.mapboxgl;
if (!mapboxgl) {
setStatus("missing-script");
return undefined;
}
const token = String(window.MAPBOX_ACCESS_TOKEN || "").trim();
if (!token) {
setStatus("missing-token");
return undefined;
}
mapboxgl.accessToken = token;
const style = String(window.LANDAI_MAPBOX_STYLE || "").trim() || "mapbox://styles/mapbox/light-v11";
if (typeof mapboxgl.supported === "function" && !mapboxgl.supported()) {
setStatus("webgl-error");
return undefined;
}
let map;
try {
map = new mapboxgl.Map({
container: node,
style,
center: [-98.6, 39.6],
zoom: 3.45,
minZoom: 2.2,
maxZoom: 15,
attributionControl: true,
cooperativeGestures: false,
scrollZoom: true,
});
} catch (err) {
setStatus("webgl-error");
console.warn("[data-store-map] Mapbox initialization failed", err);
return undefined;
}
mapRef.current = map;
const countyHoverPopup = new mapboxgl.Popup({
closeButton: false,
closeOnClick: false,
maxWidth: "240px",
offset: 12,
});
map.addControl(new mapboxgl.NavigationControl({ showCompass: false }), "bottom-right");
map.addControl(new mapboxgl.ScaleControl({ maxWidth: 120, unit: "imperial" }), "bottom-left");
const resize = () => {
try { map.resize(); }
catch (_) { /* noop */ }
};
map.on("load", () => {
map.fitBounds(
[
[-125.25, 24.35],
[-66.5, 49.85],
],
{ duration: 0, padding: { top: 108, right: 38, bottom: 34, left: 38 } },
);
addDataStoreCoverageOverlay(map)
.then(geojson => {
const features = geojson?.features || [];
node.dataset.coverageSupportedCount = String(features.filter(feature => feature?.properties?.LANDAI_MAP_CLASS === "landai").length);
node.dataset.coveragePremiumCount = String(features.filter(feature => feature?.properties?.LANDAI_MAP_CLASS !== "landai").length);
node.dataset.coverageOverlayReady = "1";
setStatus("ready");
})
.catch(err => {
node.dataset.coverageOverlayReady = "error";
setStatus("coverage-error");
console.warn("[data-store-map] County coverage overlay failed", err);
});
resize();
setTimeout(resize, 150);
setTimeout(resize, 450);
});
map.on("mouseenter", DATA_STORE_COVERAGE_FILL_LAYER_ID, () => {
map.getCanvas().style.cursor = "pointer";
});
map.on("mousemove", DATA_STORE_COVERAGE_FILL_LAYER_ID, event => {
const feature = event.features && event.features[0];
if (!feature) return;
const fips = countyFipsFromFeature(feature);
const stateName = stateNameForCountyFips(fips);
const countyName = displayCountyNameForFeature(feature, stateName);
if (!countyName) return;
countyHoverPopup
.setLngLat(event.lngLat)
.setHTML(dataStoreCountyTooltipHtml(countyName))
.addTo(map);
});
map.on("mouseleave", DATA_STORE_COVERAGE_FILL_LAYER_ID, () => {
map.getCanvas().style.cursor = "";
countyHoverPopup.remove();
});
map.on("click", DATA_STORE_COVERAGE_FILL_LAYER_ID, event => {
const feature = event.features && event.features[0];
if (!feature) return;
const fips = countyFipsFromFeature(feature);
const stateName = stateNameForCountyFips(fips) || feature?.properties?.STATE_NAME || "";
const countyName = displayCountyNameForFeature(feature, stateName);
const shouldZoomToState = !selectedCountyRef.current
&& stateName
&& map.getZoom() < DATA_STORE_STATE_CLICK_ZOOM
&& stateDrilldownRef.current !== stateName;
if (shouldZoomToState) {
stateDrilldownRef.current = stateName;
countyHoverPopup.remove();
dataStoreFitMapToState(map, stateName)
.then(didFit => {
if (!didFit) stateDrilldownRef.current = "";
})
.catch(err => {
stateDrilldownRef.current = "";
console.warn("[data-store-map] State zoom failed", err);
});
return;
}
if (stateName && countyName && onCountyRef.current) {
stateDrilldownRef.current = stateName;
dataStoreSetSelectedCountyOnMap(map, feature);
dataStoreFitMapToFeature(map, feature);
onCountyRef.current(countyName, stateName);
}
});
return () => {
mapRef.current = null;
countyHoverPopup.remove();
map.remove();
};
}, []);
return (
{status !== "ready" && (
{status === "missing-token" ? (
Mapbox needs a public access token.MAPBOX_ACCESS_TOKEN for this environment.
) : status === "missing-script" ? (
Mapbox GL did not load.
) : status === "webgl-error" ? (
Map needs WebGL to display.
) : status === "coverage-error" ? (
County coverage could not load.
) : (
Loading county coverage...
)}
)}
);
}
function BrowseCountyPanel({ countyName, stateName, onBack, onCounty, onAdd }) {
const { countyMeta, countyMetaLoading, fieldCoverage, fieldCoverageLoading } = useDataStoreCountyData(countyName, stateName);
const { loading: otherCountiesLoading, counties: otherSupportedCounties } = useSupportedCountiesInState(stateName, countyName);
const info = countyInfo(countyName);
const parcelCount = dataStoreCountyParcelCountLabel(countyMeta, countyMetaLoading);
const dataDate = dataStoreCountyDataDateLabel(countyMeta, countyMetaLoading);
const stats = [["Parcels", parcelCount], ["Data date", dataDate]];
const base = info.price;
return (
<>
{countyName}, {stateName}
{stats.map(([label, val], i) => (
))}
County parcel package
LandAI parcel schema included
One standardized set of parcel fields, with completeness shown below.
Export formats included
Every county purchase includes all download formats.
{INCLUDED_EXPORT_FORMATS.map(format =>
onAdd && onAdd(countyName, base, info.parcels.toLocaleString(), { format: INCLUDED_FORMAT_LABEL })} style={{ width: "100%", border: "none", background: GREEN, color: "#fff", fontSize: 16, fontWeight: 800, padding: "16px 0", borderRadius: 12, cursor: "pointer", fontFamily: "inherit", letterSpacing: 0.2 }}>
Add {countyName} to cart — ${base}
Need more than a few counties?
Grab the whole state, or reach out about nationwide bulk & API access.
Other counties in {stateName}
{otherCountiesLoading ? (
Loading supported counties...
) : otherSupportedCounties.length ? (
{otherSupportedCounties.map((county, i) => (
onCounty(county, stateName)} style={{ breakInside: "avoid", padding: "8px 0", fontSize: 14, fontWeight: 600, color: GREEN_DK, cursor: "pointer" }}>{county}
))}
) : (
No other supported counties in {stateName} yet.
)}
);
}
function BrowseStore({ onHome, onBrowse, onState, onCounty, onSupport, onCart, onAdd, cartCount, initialCounty }) {
const [q, setQ] = useState("");
const [searchOpen, setSearchOpen] = useState(false);
const [searchBusy, setSearchBusy] = useState(false);
const [searchMessage, setSearchMessage] = useState("");
const [selectedCounty, setSelectedCounty] = useState(initialCounty || null);
const [placeSuggestions, setPlaceSuggestions] = useState([]);
const [placesBusy, setPlacesBusy] = useState(false);
const localSuggestions = dataStoreLocalSearchSuggestions(q, 5);
const localSuggestionKeys = new Set(localSuggestions.map(item => dataStoreSearchKey(`${item.label} ${item.detail}`)));
const searchSuggestions = [
...localSuggestions,
...placeSuggestions.filter(item => !localSuggestionKeys.has(dataStoreSearchKey(`${item.label} ${item.detail}`))),
].slice(0, 8);
useEffect(() => {
setSelectedCounty(initialCounty || null);
if (initialCounty) setQ(dataStoreSearchLabelForCounty(initialCounty.countyName, initialCounty.stateName));
}, [initialCounty?.countyName, initialCounty?.stateName]);
useEffect(() => {
const query = q.trim();
if (dataStoreSearchKey(query).length < 3) {
setPlaceSuggestions([]);
setPlacesBusy(false);
return undefined;
}
let cancelled = false;
const timer = window.setTimeout(() => {
setPlacesBusy(true);
dataStoreMapboxPlaceSuggestions(query, 5)
.then(suggestions => {
if (!cancelled) setPlaceSuggestions(suggestions);
})
.catch(err => {
if (!cancelled) setPlaceSuggestions([]);
console.warn("[data-store-map] Place suggestions failed", err);
})
.finally(() => {
if (!cancelled) setPlacesBusy(false);
});
}, 260);
return () => {
cancelled = true;
window.clearTimeout(timer);
};
}, [q]);
const selectCounty = (countyName, stateName) => {
const next = { countyName, stateName };
setSelectedCounty(next);
setSearchOpen(false);
setSearchMessage("");
setQ(dataStoreSearchLabelForCounty(countyName, stateName));
onCounty(countyName, stateName);
};
const clearCountySelection = () => {
const nextStateName = selectedCounty?.stateName;
setSelectedCounty(null);
setSearchOpen(false);
setSearchMessage("");
setQ("");
if (nextStateName) onState(nextStateName);
else onBrowse();
};
const openSearchResult = async (result) => {
if (!result) return;
setQ(result.label);
setSearchOpen(false);
setSearchMessage("");
if (result.type === "state") {
onState(result.stateName);
return;
}
if (result.type === "county") {
selectCounty(result.countyName, result.stateName);
return;
}
if (result.type === "place") {
setSearchBusy(true);
try {
const countyResult = await dataStoreCountySearchResultForLngLat(result.center[0], result.center[1]);
if (countyResult) {
selectCounty(countyResult.countyName, countyResult.stateName);
return;
}
setSearchMessage("No matching county found");
setSearchOpen(true);
} catch (err) {
console.warn("[data-store-map] Place search failed", err);
setSearchMessage("Search unavailable");
setSearchOpen(true);
} finally {
setSearchBusy(false);
}
}
};
const handleSearchSubmit = async (event) => {
event.preventDefault();
const query = q.trim();
if (!query || searchBusy) return;
const localResult = dataStoreBestLocalSearchResult(query);
if (localResult) {
openSearchResult(localResult);
return;
}
setSearchBusy(true);
setSearchMessage("");
try {
const mapboxResult = await dataStoreMapboxCountySearch(query);
if (mapboxResult) {
setSearchBusy(false);
openSearchResult(mapboxResult);
return;
}
setSearchMessage("No matching county found");
setSearchOpen(true);
} catch (err) {
console.warn("[data-store-map] Search failed", err);
setSearchMessage("Search unavailable");
setSearchOpen(true);
} finally {
setSearchBusy(false);
}
};
const handleSearchChange = (event) => {
setQ(event.target.value);
setSearchMessage("");
setPlaceSuggestions([]);
setSearchOpen(true);
};
return (
{/* LEFT column — scrolls */}
{selectedCounty ? (
) : (
<>
The LandAI Data Store
Buy U.S. parcel data by the county or the whole state.
We cover 2,170+ supported counties and 136M+ parcel records, available three ways: bulk licenses , an API , and this self-serve store . Grab a single county file or license an entire state right here.
{/* stat cards */}
{STATS.map(([n, l], i) =>
Tap a county on the map, or find one in the list or search bar, to see which fields are available, then pay by card or ACH under our standard store license .
Data documentation
We gather and refresh county records from across the country and fit them into one consistent schema. Check the field dictionary, coverage report, and FAQs before you buy.
onSupport("schema")}>Parcel Schema / Data Dictionary
onSupport("coverage")}>Detailed Coverage Report
onSupport("faqs")}>Parcel Data FAQs
Need the whole country?
For nationwide bulk data, API access, or more than 3 states at once, email our team at parcels@landai.app and we'll set you up.
Parcel data by state
Jump straight to a state or county from the map and search bar, or pick a state to see all of its counties.
{STATES.map((s, i) => (
onState(s)} style={{ breakInside: "avoid", padding: "13px 0", borderBottom: `1px solid ${BORDER}`, fontSize: 16, fontWeight: 700, color: GREEN_DK, cursor: "pointer" }}>{s}
))}
)}
{/* RIGHT column — fixed map */}
{/* top controls */}
{searchOpen && q.trim() && (searchSuggestions.length > 0 || placesBusy || searchMessage) && (
{searchSuggestions.map((item, i) => (
{ event.preventDefault(); openSearchResult(item); }} style={{ width: "100%", border: "none", borderBottom: i < searchSuggestions.length - 1 || placesBusy || searchMessage ? `1px solid ${BORDER}` : "none", background: "#fff", padding: "11px 14px", display: "flex", alignItems: "center", justifyContent: "space-between", gap: 12, cursor: "pointer", fontFamily: "inherit", textAlign: "left" }}>
{item.label}
{item.detail}
))}
{placesBusy &&
Searching places...
}
{searchMessage &&
{searchMessage}
}
)}
{cartCount > 0 &&
{cartCount} }
);
}
// ---------- STATE DETAIL VIEW ----------
const FALLBACK_COUNTIES_BY_STATE = {
"North Carolina": ["Alamance County"]
};
const COUNTIES_BY_STATE = window.LANDAI_COUNTIES_BY_STATE || FALLBACK_COUNTIES_BY_STATE;
const STATE_CODES = {
"Alabama": "al",
"Alaska": "ak",
"Arizona": "az",
"Arkansas": "ar",
"California": "ca",
"Colorado": "co",
"Connecticut": "ct",
"Delaware": "de",
"District of Columbia": "dc",
"Florida": "fl",
"Georgia": "ga",
"Guam": "gu",
"Hawaii": "hi",
"Idaho": "id",
"Illinois": "il",
"Indiana": "in",
"Iowa": "ia",
"Kansas": "ks",
"Kentucky": "ky",
"Louisiana": "la",
"Maine": "me",
"Maryland": "md",
"Massachusetts": "ma",
"Michigan": "mi",
"Minnesota": "mn",
"Mississippi": "ms",
"Missouri": "mo",
"Montana": "mt",
"Nebraska": "ne",
"Nevada": "nv",
"New Hampshire": "nh",
"New Jersey": "nj",
"New Mexico": "nm",
"New York": "ny",
"North Carolina": "nc",
"North Dakota": "nd",
"Northern Mariana Islands": "mp",
"Ohio": "oh",
"Oklahoma": "ok",
"Oregon": "or",
"Pennsylvania": "pa",
"Puerto Rico": "pr",
"Rhode Island": "ri",
"South Carolina": "sc",
"South Dakota": "sd",
"Tennessee": "tn",
"Texas": "tx",
"U.S. Virgin Islands": "vi",
"Utah": "ut",
"Vermont": "vt",
"Virginia": "va",
"Washington": "wa",
"West Virginia": "wv",
"Wisconsin": "wi",
"Wyoming": "wy"
};
const CODE_TO_STATE = Object.fromEntries(Object.entries(STATE_CODES).map(([name, code]) => [code, name]));
const STATE_FIPS_TO_NAME = {
"01": "Alabama",
"02": "Alaska",
"04": "Arizona",
"05": "Arkansas",
"06": "California",
"08": "Colorado",
"09": "Connecticut",
"10": "Delaware",
"11": "District of Columbia",
"12": "Florida",
"13": "Georgia",
"15": "Hawaii",
"16": "Idaho",
"17": "Illinois",
"18": "Indiana",
"19": "Iowa",
"20": "Kansas",
"21": "Kentucky",
"22": "Louisiana",
"23": "Maine",
"24": "Maryland",
"25": "Massachusetts",
"26": "Michigan",
"27": "Minnesota",
"28": "Mississippi",
"29": "Missouri",
"30": "Montana",
"31": "Nebraska",
"32": "Nevada",
"33": "New Hampshire",
"34": "New Jersey",
"35": "New Mexico",
"36": "New York",
"37": "North Carolina",
"38": "North Dakota",
"39": "Ohio",
"40": "Oklahoma",
"41": "Oregon",
"42": "Pennsylvania",
"44": "Rhode Island",
"45": "South Carolina",
"46": "South Dakota",
"47": "Tennessee",
"48": "Texas",
"49": "Utah",
"50": "Vermont",
"51": "Virginia",
"53": "Washington",
"54": "West Virginia",
"55": "Wisconsin",
"56": "Wyoming"
};
const SUPPORT_DOCS = new Set(["start", "schema", "coverage", "license", "faqs"]);
const STORE_BASE = "/data-store";
function safeDecode(value) {
try { return decodeURIComponent(value); }
catch { return value; }
}
function slugify(value) {
return String(value || "")
.trim()
.normalize("NFD")
.replace(/[\u0300-\u036f]/g, "")
.toLowerCase()
.replace(/&/g, " and ")
.replace(/u\.s\./g, "us")
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-+|-+$/g, "");
}
function titleFromSlug(slug) {
return String(slug || "")
.split("-")
.filter(Boolean)
.map(part => part.charAt(0).toUpperCase() + part.slice(1))
.join(" ");
}
function countiesForState(stateName) {
return COUNTIES_BY_STATE[stateName] || [];
}
function stateCodeForName(stateName) {
return STATE_CODES[stateName] || "";
}
function stateNameForSlug(slug) {
const clean = slugify(slug);
return CODE_TO_STATE[clean] || STATES.find(state => slugify(state) === clean) || "";
}
function countyNameForSlug(stateName, slug) {
const clean = slugify(slug);
return countiesForState(stateName).find(county => countySlug(county) === clean || slugify(county) === clean) || titleFromSlug(clean);
}
function countySlug(countyName) {
const shortened = String(countyName || "")
.replace(/\s+(county|parish|borough|municipality|census area|municipio)$/i, "")
.trim();
return slugify(shortened || countyName);
}
function normalizeDoc(doc) {
return SUPPORT_DOCS.has(doc) ? doc : "schema";
}
function normalizeStoreRoute(route, fallback = {}) {
return {
view: route.view || fallback.view || "landing",
stateName: route.stateName || fallback.stateName || "North Carolina",
countyName: route.countyName || fallback.countyName || "Alamance",
supportDoc: normalizeDoc(route.supportDoc || fallback.supportDoc || "schema")
};
}
function dataStorePath(view, stateName, countyName, supportDoc) {
if (view === "browse") return `${STORE_BASE}/browse`;
if (view === "cart") return `${STORE_BASE}/cart`;
if (view === "checkoutSuccess") return `${STORE_BASE}/checkout/success`;
if (view === "support") return `${STORE_BASE}/docs/${normalizeDoc(supportDoc)}`;
const stateCode = stateCodeForName(stateName) || slugify(stateName) || "nc";
if (view === "state") return `${STORE_BASE}/${stateCode}`;
if (view === "coverage") return `${STORE_BASE}/${stateCode}/coverage`;
if (view === "browseCounty") return `${STORE_BASE}/${stateCode}/${countySlug(countyName) || "alamance"}`;
if (view === "county") return `${STORE_BASE}/${stateCode}/${countySlug(countyName) || "alamance"}`;
return STORE_BASE;
}
function readDataStoreRoute() {
const parts = window.location.pathname.split("/").filter(Boolean).map(safeDecode);
const storeIndex = parts.findIndex(part => ["data-store", "datastore", "date-store"].includes(slugify(part)));
if (storeIndex < 0) return normalizeStoreRoute({});
const segments = parts.slice(storeIndex + 1).map(slugify);
const [first, second] = segments;
if (!first) return normalizeStoreRoute({});
if (first === "browse") return normalizeStoreRoute({ view: "browse" });
if (first === "cart") return normalizeStoreRoute({ view: "cart" });
if (first === "checkout" && second === "success") return normalizeStoreRoute({ view: "checkoutSuccess" });
if (first === "docs" || first === "support") return normalizeStoreRoute({ view: "support", supportDoc: normalizeDoc(second) });
const stateName = stateNameForSlug(first);
if (!stateName) return normalizeStoreRoute({ view: "browse" });
if (second === "coverage") return normalizeStoreRoute({ view: "coverage", stateName });
if (second) return normalizeStoreRoute({ view: "browseCounty", stateName, countyName: countyNameForSlug(stateName, second) });
return normalizeStoreRoute({ view: "state", stateName });
}
function hashStr(s) { let h = 0; for (let i = 0; i < s.length; i++) h = (h * 31 + s.charCodeAt(i)) >>> 0; return h; }
function countyInfo(name) {
const h = hashStr(name);
const parcels = 6000 + (h % 410000);
const mo = String(1 + (h % 6)).padStart(2, "0");
const da = String(1 + (h % 27)).padStart(2, "0");
return { parcels, date: `2026-${mo}-${da}`, price: COUNTY_STORE_PRICE };
}
function CountyIcon({ feature }) {
const path = dataStoreFeatureSvgPath(feature);
return (
);
}
function CountyRow({ name, feature, loading, onOpen, onAdd }) {
const info = countyInfo(name);
const meta = feature ? dataStoreCountyMetadataFromFeature(feature) : null;
const supported = dataStoreCountyIsSupported(feature);
const purchasable = !loading && supported;
const parcelLabel = supported ? dataStoreCountyParcelCountLabel(meta, loading) : "";
const dataDate = supported ? dataStoreCountyDataDateLabel(meta, loading) : "";
const detailParts = [];
if (loading) detailParts.push("Loading coverage...");
else if (!supported) detailParts.push("Not supported");
else {
detailParts.push(`${parcelLabel} parcels`);
if (dataDate && dataDate !== "Unknown") detailParts.push(`data date ${dataDate}`);
else detailParts.push("data date unknown");
}
const records = meta?.parcelCount ? meta.parcelCount.toLocaleString() : info.parcels.toLocaleString();
const rowColor = purchasable ? GREEN_DK : "#7d8581";
const muted = !purchasable;
return (
{name}
{detailParts.join(" · ")}
{loading ? "..." : purchasable ? `$${info.price}` : "$--"}
{ e.stopPropagation(); if (purchasable && onAdd) onAdd(name, info.price, records); }} style={{ border: `1.5px solid ${purchasable ? GREEN : "#b8bbb6"}`, background: purchasable ? "#fff" : "#eeeeea", color: purchasable ? GREEN : "#a0a49f", fontWeight: 700, fontSize: 13, padding: "8px 16px", borderRadius: 99, cursor: purchasable ? "pointer" : "not-allowed", fontFamily: "inherit" }}>Add
);
}
function StateMapboxMap({ stateName, onCounty }) {
const mapNode = useRef(null);
const mapRef = useRef(null);
const stateNameRef = useRef(stateName);
const onCountyRef = useRef(onCounty);
const [status, setStatus] = useState("loading");
useEffect(() => {
stateNameRef.current = stateName;
}, [stateName]);
useEffect(() => {
onCountyRef.current = onCounty;
}, [onCounty]);
useEffect(() => {
const map = mapRef.current;
if (!map || status !== "ready") return undefined;
let cancelled = false;
loadDataStoreCoverageGeoJSON()
.then(geojson => {
if (cancelled) return false;
dataStoreSetStateOutlineOnMap(map, geojson, stateName);
return dataStoreFitMapToState(map, stateName, 650);
})
.then(didFit => {
if (!cancelled && !didFit) console.warn("[data-store-state-map] State bounds unavailable", stateName);
})
.catch(err => console.warn("[data-store-state-map] State zoom failed", err));
return () => {
cancelled = true;
};
}, [stateName, status]);
useEffect(() => {
const node = mapNode.current;
if (!node || mapRef.current) return undefined;
const mapboxgl = window.mapboxgl;
if (!mapboxgl) {
setStatus("missing-script");
return undefined;
}
const token = String(window.MAPBOX_ACCESS_TOKEN || "").trim();
if (!token) {
setStatus("missing-token");
return undefined;
}
mapboxgl.accessToken = token;
const style = String(window.LANDAI_MAPBOX_STYLE || "").trim() || "mapbox://styles/mapbox/light-v11";
if (typeof mapboxgl.supported === "function" && !mapboxgl.supported()) {
setStatus("webgl-error");
return undefined;
}
let map;
try {
map = new mapboxgl.Map({
container: node,
style,
center: [-98.6, 39.6],
zoom: 3.4,
minZoom: 2.2,
maxZoom: 15,
attributionControl: true,
cooperativeGestures: false,
scrollZoom: true,
});
} catch (err) {
setStatus("webgl-error");
console.warn("[data-store-state-map] Mapbox initialization failed", err);
return undefined;
}
mapRef.current = map;
const countyHoverPopup = new mapboxgl.Popup({
closeButton: false,
closeOnClick: false,
maxWidth: "240px",
offset: 12,
});
map.addControl(new mapboxgl.NavigationControl({ showCompass: false }), "bottom-right");
map.addControl(new mapboxgl.ScaleControl({ maxWidth: 120, unit: "imperial" }), "bottom-left");
const resize = () => {
try { map.resize(); }
catch (_) { /* noop */ }
};
map.on("load", () => {
addDataStoreCoverageOverlay(map)
.then(geojson => {
dataStoreSetStateOutlineOnMap(map, geojson, stateNameRef.current);
node.dataset.coverageOverlayReady = "1";
setStatus("ready");
dataStoreFitMapToState(map, stateNameRef.current, 0);
})
.catch(err => {
node.dataset.coverageOverlayReady = "error";
setStatus("coverage-error");
console.warn("[data-store-state-map] County coverage overlay failed", err);
});
resize();
setTimeout(resize, 150);
setTimeout(resize, 450);
});
map.on("mouseenter", DATA_STORE_COVERAGE_FILL_LAYER_ID, () => {
map.getCanvas().style.cursor = "pointer";
});
map.on("mousemove", DATA_STORE_COVERAGE_FILL_LAYER_ID, event => {
const feature = event.features && event.features[0];
if (!feature) return;
const fips = countyFipsFromFeature(feature);
const featureStateName = stateNameForCountyFips(fips) || feature?.properties?.STATE_NAME || "";
if (slugify(featureStateName) !== slugify(stateNameRef.current)) {
countyHoverPopup.remove();
return;
}
const countyName = displayCountyNameForFeature(feature, featureStateName);
if (!countyName) return;
countyHoverPopup
.setLngLat(event.lngLat)
.setHTML(dataStoreCountyTooltipHtml(countyName))
.addTo(map);
});
map.on("mouseleave", DATA_STORE_COVERAGE_FILL_LAYER_ID, () => {
map.getCanvas().style.cursor = "";
countyHoverPopup.remove();
});
map.on("click", DATA_STORE_COVERAGE_FILL_LAYER_ID, event => {
const feature = event.features && event.features[0];
if (!feature) return;
const fips = countyFipsFromFeature(feature);
const featureStateName = stateNameForCountyFips(fips) || feature?.properties?.STATE_NAME || "";
if (slugify(featureStateName) !== slugify(stateNameRef.current)) return;
if (!dataStoreCountyIsSupported(feature)) return;
const countyName = displayCountyNameForFeature(feature, featureStateName);
if (!countyName || !onCountyRef.current) return;
countyHoverPopup.remove();
dataStoreSetSelectedCountyOnMap(map, feature);
dataStoreFitMapToFeature(map, feature);
onCountyRef.current(countyName, featureStateName);
});
return () => {
mapRef.current = null;
countyHoverPopup.remove();
map.remove();
};
}, []);
return (
{status !== "ready" && (
{status === "missing-token" ? (
Mapbox needs a public access token.MAPBOX_ACCESS_TOKEN for this environment.
) : status === "missing-script" ? (
Mapbox GL did not load.
) : status === "webgl-error" ? (
Map needs WebGL to display.
) : status === "coverage-error" ? (
County coverage could not load.
) : (
Loading {stateName} map...
)}
)}
);
}
function MapControls({ q, setQ, onCart, cartCount }) {
return (
{cartCount > 0 &&
{cartCount} }
);
}
function StateView({ stateName, onHome, onBrowse, onBack, onCounty, onCoverage, onBuy, onAdd, onCart, cartCount }) {
const [q, setQ] = useState("");
const [countyFilter, setCountyFilter] = useState("all");
const [countySort, setCountySort] = useState("supported");
const counties = countiesForState(stateName);
const [stateCoverage, setStateCoverage] = useState({ loading: true, featuresBySlug: new Map(), stats: null });
useEffect(() => {
let cancelled = false;
setStateCoverage({ loading: true, featuresBySlug: new Map(), stats: null });
loadDataStoreCoverageGeoJSON()
.then(geojson => {
if (cancelled) return;
const featuresBySlug = new Map();
(geojson?.features || []).forEach(feature => {
const fips = countyFipsFromFeature(feature);
const featureStateName = stateNameForCountyFips(fips) || feature?.properties?.STATE_NAME || "";
if (slugify(featureStateName) !== slugify(stateName)) return;
const countyName = displayCountyNameForFeature(feature, stateName);
if (countyName) featuresBySlug.set(countySlug(countyName), feature);
});
let parcelTotal = 0;
let supportedCount = 0;
let latestDate = "";
let latestTime = 0;
counties.forEach(county => {
const feature = featuresBySlug.get(countySlug(county));
if (!feature) return;
const meta = dataStoreCountyMetadataFromFeature(feature);
parcelTotal += meta.parcelCount || 0;
if (dataStoreCountyIsSupported(feature)) supportedCount += 1;
const dateLabel = dataStoreCountyDataDateLabel(meta, false);
const parsed = Date.parse(dateLabel);
if (!Number.isNaN(parsed) && parsed > latestTime) {
latestTime = parsed;
latestDate = dateLabel;
}
});
const totalCount = counties.length || featuresBySlug.size;
const stats = [
["Parcels", parcelTotal ? parcelTotal.toLocaleString() : "Unknown"],
["Counties online", `${supportedCount} / ${totalCount}`],
["Latest data date", latestDate || "Unknown"],
["Not supported", Math.max(totalCount - supportedCount, 0).toLocaleString()],
];
setStateCoverage({ loading: false, featuresBySlug, stats });
})
.catch(err => {
console.warn("[data-store-state] State coverage unavailable", err);
if (!cancelled) setStateCoverage({ loading: false, featuresBySlug: new Map(), stats: null });
});
return () => {
cancelled = true;
};
}, [stateName]);
const stats = stateCoverage.stats || [
["Parcels", "Loading..."],
["Counties online", `Loading... / ${counties.length || "..."}`],
["Latest data date", "Loading..."],
["Not supported", "Loading..."],
];
const countyRows = counties.map(county => {
const feature = stateCoverage.featuresBySlug.get(countySlug(county));
const supported = dataStoreCountyIsSupported(feature);
return { county, feature, supported };
});
const supportedRows = countyRows.filter(row => row.supported);
const unsupportedRows = stateCoverage.loading ? [] : countyRows.filter(row => !row.supported);
const statewidePrice = supportedRows.length * STATE_STORE_PRICE_PER_SUPPORTED_COUNTY;
const stateBuyDisabled = stateCoverage.loading || supportedRows.length === 0;
const visibleCountyRows = countyRows
.filter(row => {
if (stateCoverage.loading) return true;
if (countyFilter === "supported") return row.supported;
if (countyFilter === "unsupported") return !row.supported;
return true;
})
.sort((a, b) => {
if (countySort === "supported" && !stateCoverage.loading) {
if (a.supported !== b.supported) return a.supported ? -1 : 1;
}
return a.county.localeCompare(b.county);
});
return (
{stateName} Parcel Data
{stats.map(([label, val], i) => (
))}
Statewide data
Get every supported county in {stateName} in a single purchase, refreshed on a rolling schedule.
{stateCoverage.loading ? "Loading state price..." : supportedRows.length ? `Buy the entire state - ${formatStoreCurrency(statewidePrice)}` : "State not available"}
Coverage report
Data by county
Tap a supported county to see its fields, review coverage, and add it to your cart. Each county is a one-time purchase under our standard store license.
{stateCoverage.loading ? "Loading county coverage..." : `${supportedRows.length.toLocaleString()} supported · ${unsupportedRows.length.toLocaleString()} not supported`}
Show
setCountyFilter(e.target.value)} style={{ border: `1px solid ${BORDER}`, borderRadius: 8, background: "#fff", color: INK, padding: "7px 9px", fontFamily: "inherit", fontSize: 13, fontWeight: 700 }}>
All counties
Supported only
Not supported
Sort
setCountySort(e.target.value)} style={{ border: `1px solid ${BORDER}`, borderRadius: 8, background: "#fff", color: INK, padding: "7px 9px", fontFamily: "inherit", fontSize: 13, fontWeight: 700 }}>
Supported first
Name A-Z
{visibleCountyRows.map(({ county, feature }) => onCounty(county)} onAdd={onAdd} />)}
);
}
// ---------- COUNTY DETAIL / CHECKOUT VIEW ----------
const FIELD_SECTION_ORDER = ["Overview", "Location", "Mailing Address", "Land", "Value", "Building", "Legal", "Additional Details", "Links"];
function FieldRow({ name, pct }) {
const cleanPct = Math.max(0, Math.min(100, Math.round(Number(pct || 0))));
const low = cleanPct < 50;
return (
{name}
{cleanPct}%
);
}
function fieldCoverageGroups(fieldCoverage) {
const fields = Array.isArray(fieldCoverage?.fields) ? fieldCoverage.fields : [];
const groups = new Map();
fields.forEach(field => {
const section = String(field?.section || "Other").trim() || "Other";
const label = String(field?.label || field?.id || "").trim();
if (!label) return;
const pct = Number(field?.pct);
if (!Number.isFinite(pct)) return;
if (!groups.has(section)) groups.set(section, []);
groups.get(section).push({ label, pct });
});
return Array.from(groups.entries())
.sort(([a], [b]) => {
const ai = FIELD_SECTION_ORDER.indexOf(a);
const bi = FIELD_SECTION_ORDER.indexOf(b);
return (ai === -1 ? 999 : ai) - (bi === -1 ? 999 : bi) || a.localeCompare(b);
})
.map(([section, rows]) => ({ section, rows }));
}
function FieldCoverageSection({ fieldCoverage, loading }) {
const groups = fieldCoverageGroups(fieldCoverage);
const fieldCount = groups.reduce((sum, group) => sum + group.rows.length, 0);
const parcelCount = Number(fieldCoverage?.active_parcel_count || 0);
const parcelText = parcelCount > 0 ? ` across ${parcelCount.toLocaleString()} active parcels` : "";
return (
Fields included
{loading ? (
<>
Loading real field coverage for this county...
Checking the latest county cache.
) : fieldCount ? (
<>
{fieldCount} parcel detail fields with real completeness{parcelText}.
{groups.map(group => (
{group.section}
{group.rows.map(row =>
)}
))}
) : (
<>
Field coverage has not been generated for this county yet.
The nightly coverage refresh will populate this when county parcel data is available.
)}
);
}
function IncludedFormatChip({ label }) {
return (
{label}
);
}
function CountyMap() {
// zoomed county — purple parcel fill
const shape = "M 120 90 L 540 80 L 560 150 L 552 250 L 430 280 L 300 300 L 150 290 L 110 200 Z";
const dots = [];
for (let i = 0; i < 900; i++) {
const x = 110 + (Math.sin(i * 12.9) * 0.5 + 0.5) * 450;
const y = 80 + (Math.cos(i * 7.7) * 0.5 + 0.5) * 220;
dots.push(
);
}
return (
{dots}
`M ${110 + i * 12} 70 L ${110 + i * 12 + Math.sin(i) * 4} 310`).join(" ")} />
`M 100 ${75 + i * 12} L 575 ${75 + i * 12 + Math.cos(i) * 4}`).join(" ")} />
);
}
function CountyView({ countyName, stateName, onHome, onBrowse, onBack, onCounty, onAdd, onCart, cartCount }) {
const [q, setQ] = useState("");
const { countyMeta, countyMetaLoading, fieldCoverage, fieldCoverageLoading } = useDataStoreCountyData(countyName, stateName);
const { loading: otherCountiesLoading, counties: otherSupportedCounties } = useSupportedCountiesInState(stateName, countyName);
const info = countyInfo(countyName);
const stats = [
["Parcels", dataStoreCountyParcelCountLabel(countyMeta, countyMetaLoading)],
["Data date", dataStoreCountyDataDateLabel(countyMeta, countyMetaLoading)],
];
const base = info.price;
const stateAbbr = (stateCodeForName(stateName) || "").toUpperCase();
return (
{/* LEFT — scrolls */}
{countyName}, {stateName}
{/* stats */}
{stats.map(([label, val], i) => (
))}
{/* product package card */}
County parcel package
LandAI parcel schema included
One standardized set of parcel fields, with completeness shown below.
{/* format */}
Export formats included
Every county purchase includes all download formats.
{INCLUDED_EXPORT_FORMATS.map(f =>
{/* primary CTA */}
onAdd(countyName, base, info.parcels.toLocaleString(), { format: INCLUDED_FORMAT_LABEL })} style={{ width: "100%", border: "none", background: GREEN, color: "#fff", fontSize: 16, fontWeight: 800, padding: "16px 0", borderRadius: 12, cursor: "pointer", fontFamily: "inherit", letterSpacing: 0.2 }}>
Add {countyName} to cart — ${base}
{/* nationwide callout */}
Need more than a few counties?
Grab the whole state, or reach out about nationwide bulk & API access.
{/* other counties */}
Other counties in {stateName}
{otherCountiesLoading ? (
Loading supported counties...
) : otherSupportedCounties.length ? (
{otherSupportedCounties.map((c, i) => (
onCounty(c, stateName)} style={{ breakInside: "avoid", padding: "8px 0", fontSize: 14, fontWeight: 600, color: GREEN_DK, cursor: "pointer" }}>{c}
))}
) : (
No other supported counties in {stateName} yet.
)}
{/* RIGHT — county map */}
{countyName}, {stateAbbr}
Sources: LandAI, Esri, USGS, OpenStreetMap contributors
);
}
// ---------- SUPPORT / DOCS VIEW ----------
const PARCEL_DICTIONARY_GROUPS = [
["Overview", [
["owner_name", "Land Owner name", "string", "Combined owner name shown at the top of the parcel detail panel."],
["site_address", "Address", "string", "Primary physical/situs address shown at the top of the parcel detail panel."],
["parcel_id", "Parcel ID", "string", "County assessor parcel identifier or APN."],
["source_updated_at", "Last updated", "date", "Date or data vintage reported by the county/state source for this parcel record."],
["ingested_at", "Ingested", "timestamp", "When LandAI most recently loaded this parcel row into our database."],
]],
["Location", [
["location_street_address", "Street Address", "string", "Standardized physical street address for the parcel."],
["location_city", "City", "string", "Physical address city or locality."],
["location_state", "State", "string", "Physical address state."],
["location_zip", "Zip Code", "string", "Physical address ZIP Code."],
["location_county", "County", "string", "County name associated with the parcel."],
]],
["Mailing Address", [
["mailing_street_address", "Street Address", "string", "Owner mailing street address from the county source."],
["mailing_city", "City", "string", "Owner mailing city."],
["mailing_state", "State", "string", "Owner mailing state."],
["mailing_zip", "Zip Code", "string", "Owner mailing ZIP Code."],
["owner_occupied", "Owner Occupied", "boolean", "Whether the owner mailing address appears to match the parcel address."],
]],
["Land", [
["deeded_acres", "Deeded Acres", "number", "Acreage reported by the county record when available."],
["calculated_acres", "Calculated Acres", "number", "Acreage calculated from LandAI parcel geometry."],
["land_use", "Land Use", "string", "Human-readable land-use or property-use description."],
["land_use_code", "Land Use Code", "string", "Raw land-use code from the county source."],
["zoning", "Zoning", "string", "Zoning code or zoning description when the county publishes it."],
["property_class", "Property Class", "string", "County property class, class code, or building use classification."],
]],
["Value", [
["sale_price", "Sale Price", "currency", "Most recent sale or transfer price when available."],
["transfer_date", "Transfer Date", "date", "Most recent sale, transfer, or recording date."],
["assessed_total_value", "Assessed Total Value", "currency", "Total assessed value reported by the county."],
["market_total_value", "Market Total Value", "currency", "Total market value reported by the county."],
["market_improvement_value", "Market Improvement Value", "currency", "Market value assigned to improvements or structures."],
["market_land_value", "Market Land Value", "currency", "Market value assigned to the land."],
["tax_amount", "Tax Amount", "currency", "Most recent tax amount when published by the county source."],
["tax_year", "Tax Year", "integer", "Tax year associated with the tax or assessment values."],
]],
["Building", [
["building_sqft", "Sq Ft", "number", "Building area or total structure square footage."],
["year_built", "Year Built", "integer", "Year the primary building was built."],
["bedrooms", "Bedrooms", "number", "Bedroom count for residential records when available."],
["baths_total", "Baths Total", "number", "Total bathroom count for residential records when available."],
["stories", "Stories", "number", "Number of stories reported for the primary structure."],
["building_count", "Building Count", "integer", "Count of buildings or structures associated with the parcel."],
]],
["Legal", [
["legal_description", "Legal Description", "string", "Legal description text from the county record."],
["account_type", "Account Type", "string", "County account, roll, or property account type when provided."],
["assesspro_id", "AssessPro ID", "string", "AssessPro identifier for counties that publish it."],
]],
["Additional Details", [
["school_district", "School District", "string", "School district associated with the parcel."],
["land_cover", "Land Cover", "string", "Land cover classification when enrichment is available."],
["crop_cover", "Crop Cover", "string", "Crop cover classification when enrichment is available."],
["elevation", "Elevation", "number", "Elevation associated with the parcel location."],
["adjacent_acreage", "Adjacent Acreage (Same Owner)", "number", "Nearby acreage held by the same owner where available."],
["census_place", "Census Place", "string", "Census place or incorporated area for the parcel."],
["section_township_range", "Section-Township-Range", "string", "Public land survey section-township-range reference where available."],
["census_tract", "Census Tract", "string", "Census tract identifier associated with the parcel."],
["census_block", "Census Block", "string", "Census block identifier associated with the parcel."],
]],
["Links", [
["tax_assessment_link", "Tax Assessment", "url", "County tax assessment or property-card link when the source provides one."],
]],
];
const FAQS = [
["How accurate are the parcel boundaries?", "Boundaries come straight from county and city assessor offices, then we line them up into one consistent national geometry. They match the official tax record, but they're not a substitute for a recorded survey. Every county page shows its refresh date and coverage."],
["How often is the data refreshed?", "Most counties update on a rolling 30-90 day cycle, and busy counties more often. The exact data date is on every county page, and if you buy a whole state we re-deliver it as counties update."],
["What formats can I download?", "Every county purchase includes FileGDB, Shapefile, GeoPackage, GeoJSON, and CSV. The fields stay the same across formats, so nothing breaks when you move between tools."],
["Is owner and contact info always available?", "Owner of record shows up on about 99% of parcels. Mailing addresses and second owners depend on the county — the Data Dictionary lists coverage field by field, so you know what you're getting before you pay."],
["What does the standard license allow?", "Use it, analyze it, and build it into your own apps. Reselling or publicly republishing the raw data needs a separate license — get in touch and we'll sort out bulk or redistribution terms."],
["Can I get the whole country or scheduled delivery?", "Yes. The store is built for a handful of counties or a few states. For nationwide coverage, API access, or scheduled refreshes, reach out and we'll set up a bulk license."],
["Do you offer an API?", "Yes. API access is available for bulk and enterprise plans with live parcel and tile endpoints. Reach out and we'll set up the right plan."],
];
function FaqItem({ q, a, open, onToggle }) {
return (
);
}
function SupportShell({ doc, setDoc, onHome, onBrowse, children }) {
const nav = [["start", "Getting started"], ["schema", "Data dictionary"], ["coverage", "Coverage report"], ["license", "Licensing"], ["faqs", "FAQs"]];
return (
{/* sidebar */}
Support
{nav.map(([k, l]) => (
setDoc(k)} style={{ padding: "10px 14px", borderRadius: 9, fontSize: 15, fontWeight: 600, cursor: "pointer", color: doc === k ? "#fff" : INK, background: doc === k ? INK : "transparent" }}>{l}
))}
Still stuck?
Our data team replies within one business day.
Contact support
{/* content scrolls */}
{children}
);
}
function DataDictionaryDoc() {
const [q, setQ] = useState("");
const query = q.trim().toLowerCase();
const total = PARCEL_DICTIONARY_GROUPS.reduce((s, g) => s + g[1].length, 0);
const match = (f, group) => {
if (!query) return true;
return [group, f[0], f[1], f[2], f[3]].some(value => String(value || "").toLowerCase().includes(query));
};
return (
Reference
Parcel data dictionary
These {total} fields mirror the LandAI web and mobile parcel detail panel. County pages show real completeness for each field; this dictionary defines the app label, export/API key, type, and meaning.
{PARCEL_DICTIONARY_GROUPS.map(([group, fields], gi) => {
const shown = fields.filter(field => match(field, group));
if (!shown.length) return null;
return (
{group}
{/* header */}
App label
Export/API key
Type
Description
{shown.map((f, i) => (
{f[1]}
{f[0]}
{f[2]}
{f[3]}
))}
);
})}
{query && !PARCEL_DICTIONARY_GROUPS.some(([group, fields]) => fields.some(field => match(field, group))) && (
No parcel fields match "{q}".
)}
);
}
function FaqDoc() {
const [open, setOpen] = useState(0);
return (
Help
Parcel data FAQs
The stuff people ask us most — coverage, accuracy, formats, and licensing. Still stuck? Reach the team from the sidebar.
{FAQS.map(([q, a], i) => setOpen(open === i ? -1 : i)} />)}
);
}
function SimpleDoc({ title, eyebrow, body }) {
return (
{eyebrow}
{title}
{body.map((p, i) =>
{p}
)}
);
}
function SupportView({ doc, onHome, onBrowse, onDocChange }) {
const d = normalizeDoc(doc);
const setD = onDocChange || (() => {});
let content;
if (d === "schema") content =
;
else if (d === "faqs") content =
;
else if (d === "coverage") content =
;
else if (d === "license") content =
;
else content =
;
return
{content} ;
}
// ---------- STATE COVERAGE REPORT ----------
const COV_COLS = [
["owner", "Owner"],
["site", "Site address"],
["mail", "Mailing address"],
["zoning", "Zoning"],
["bldg", "Building footprint"],
["value", "Assessed value"],
["sale", "Last sale"],
];
function covPct(county, key) {
const h = hashStr(county + key);
// realistic ranges per field
const ranges = { owner: [95, 100], site: [88, 99], mail: [80, 99], zoning: [55, 92], bldg: [70, 95], value: [85, 99], sale: [60, 90] };
const [lo, hi] = ranges[key];
return lo + (h % (hi - lo + 1));
}
function CovCell({ pct }) {
const low = pct < 70, mid = pct < 85;
const color = low ? "#C0712E" : mid ? "#B89331" : GREEN;
return (
);
}
function CoverageReportView({ stateName, onHome, onBrowse, onBack, onCounty }) {
const [q, setQ] = useState("");
const counties = countiesForState(stateName);
const shown = counties.filter(c => c.toLowerCase().includes(q.toLowerCase()));
// statewide averages
const avg = COV_COLS.map(([k]) => Math.round(counties.reduce((s, c) => s + covPct(c, k), 0) / counties.length));
return (
Coverage report
{stateName} field coverage
How complete each field is, county by county, across {stateName}. The percentages show how many parcels actually carry a value for each one. Tap a county to buy it or dig into its full schema.
{/* statewide summary */}
{COV_COLS.map(([k, label], i) => (
))}
{/* search */}
{/* table */}
{/* header */}
County
{COV_COLS.map(([k, label]) => (
{label}
))}
{shown.map((c, i) => (
onCounty(c)} style={{ display: "flex", alignItems: "center", padding: "14px 22px", borderBottom: i < shown.length - 1 ? "1px solid #eeece2" : "none", cursor: "pointer" }}>
{c}
{countyInfo(c).parcels.toLocaleString()} parcels
{COV_COLS.map(([k]) => (
))}
))}
● ≥85% complete ● 70–84% ● <70% — varies by county recorder
);
}
// ---------- CART / CHECKOUT ----------
function CartField({ label, sub, placeholder, select, options, value, onChange, type = "text" }) {
const fieldStyle = { marginTop: 7, border: `1.5px solid ${BORDER}`, borderRadius: 10, height: 48, background: "#fff", display: "flex", alignItems: "center", padding: "0 16px", fontSize: 15, color: INK, fontFamily: "inherit", width: "100%", outline: "none" };
return (
{label}
{sub &&
{sub}
}
{select ? (
onChange && onChange(e.target.value)} style={{ ...fieldStyle, appearance: "none", color: value ? INK : "#9aa39e" }}>
{placeholder}
{(options || []).map(option => {option} )}
) : (
onChange && onChange(e.target.value)} placeholder={placeholder} style={{ ...fieldStyle, color: INK }} />
)}
);
}
function PayTab({ icon, label, active, onClick }) {
return (
{icon}
{label}
);
}
function Checkbox({ checked, onToggle, children }) {
return (
);
}
function LicenseHeading({ children }) {
return
{children}
;
}
function LandAiParcelDataLicense() {
const highlightItems = [
"We do our best to clean, check, and standardize the data, but it is offered as-is.",
"Purchased data cannot be resold or redistributed as raw files. Derivative works are OK.",
"We cannot offer refunds on purchased data.",
"Attribution is appreciated where possible.",
];
return (
The highlights (the full license below is what applies):
{highlightItems.map((item, index) => (
{item}
))}
Data Store License Agreement
By placing an order for parcel data through the LandAI Data Store, the purchaser, customer, or organization named at checkout ("Licensee" or "you") accepts this Data Store License Agreement with LandAI ("LandAI", "Licensor", "we", or "us").
LandAI will provide Licensee with a one-time export of the selected parcel data package. Unless a separate written agreement says otherwise, the purchased export does not include automatic future updates.
Terms and Conditions
Licensee receives only a limited right to use the purchased data. No ownership interest, copyright, trademark, database right, trade secret, or other proprietary right in the data is transferred to Licensee.
LandAI grants Licensee a nonexclusive, non-transferable license to use the purchased data for Licensee's internal business, analysis, mapping, research, application, and operational workflows during the license term.
Licensee may not resell, sublicense, publish, transfer, or otherwise make a substantial portion of the raw data available to a third party. Licensee may not create, offer, or sell a raw parcel-data product or service that competes with LandAI's data store, bulk data, or API products.
Licensee may not upload the raw data to, train, enrich, or use it with a public artificial intelligence large language model or other public third-party AI service, nor may Licensee use the raw data with any blockchain product or service. Licensee may use the data with its own private, proprietary AI systems.
Licensee may load the data into internal databases, GIS systems, search servers, analytics tools, geocoding systems, reverse-geocoding systems, and internal applications. Licensee may use the data to label other geometries, associate parcel attributes with buildings or coordinates, create derived analyses, and render parcel polygons in customer-facing maps if the implementation reasonably prevents users from extracting a substantial portion of the parcel geometries or raw records.
Licensee may create derivative works, analyses, reports, visualizations, models, scores, and aggregated outputs based on the data, so long as those outputs do not disclose or redistribute a substantial portion of the raw data.
Licensee will not remove, obscure, or alter any proprietary notices included with the data. Attribution to LandAI as a data source is appreciated, and should be included where reasonably practical for public-facing maps, pages, reports, or applications that use the purchased data.
Limited Warranty
The data is provided "as is" and "as available", without warranty or support of any kind. LandAI does not warrant that the data is complete, current, accurate, error-free, fit for a particular purpose, or suitable for legal, surveying, title, tax, valuation, lending, emergency, or regulatory decisions. Licensee relies on the data at Licensee's own risk.
Term and Termination
The license term begins on the purchase date and continues until the one-year anniversary of that date unless terminated earlier under this Agreement or extended in a separate written agreement. When the term ends, Licensee must stop using and delete the raw data unless LandAI has granted a renewal or replacement license.
LandAI may terminate this license if Licensee materially breaches these terms. Upon termination, Licensee must stop using and delete the raw data.
No Refunds
All purchases are final. LandAI does not provide refunds, credits, or prorated billing for purchased data.
Governing Law and Forum
This Agreement is governed by the laws of the State of North Carolina, without regard to conflict-of-law rules. Any legal action to enforce this Agreement must be brought in the state or federal courts located in Wake County, North Carolina, unless applicable law requires otherwise. The prevailing party in an action to enforce this Agreement may recover reasonable legal fees and costs.
);
}
function CartView({ cart, setCart, onHome, onBrowse, onBack }) {
const [buyer, setBuyer] = useState({ name: "", email: "" });
const [checks, setChecks] = useState({ license: false, sample: false, emails: false });
const [checkoutBusy, setCheckoutBusy] = useState(false);
const [checkoutError, setCheckoutError] = useState("");
const total = cart.reduce((s, i) => s + i.price, 0);
const remove = (idx) => setCart(c => c.filter((_, i) => i !== idx));
const tog = (k) => setChecks(c => ({ ...c, [k]: !c[k] }));
const setBuyerField = (key, value) => {
setBuyer(current => ({ ...current, [key]: value }));
setCheckoutError("");
};
const canCheckout = cart.length > 0 && checks.license && buyer.name.trim() && buyer.email.trim() && !checkoutBusy;
const startCheckout = async () => {
if (!cart.length) return;
if (!buyer.name.trim() || !buyer.email.trim()) {
setCheckoutError("Enter your name and email before checkout.");
return;
}
if (!checks.license) {
setCheckoutError("Accept the parcel data license before checkout.");
return;
}
setCheckoutBusy(true);
setCheckoutError("");
try {
const response = await fetch("/api/checkout-create-session", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
buyer,
items: cart,
licenseAccepted: checks.license,
sampleAcknowledged: checks.sample,
marketingOptIn: checks.emails,
}),
});
const payload = await response.json().catch(() => ({}));
if (!response.ok || !payload.url) throw new Error(payload.error || "Checkout could not be started.");
window.location.assign(payload.url);
} catch (err) {
setCheckoutError(err.message || "Checkout could not be started.");
setCheckoutBusy(false);
}
};
return (
{/* LEFT — cart */}
Shopping cart
{cart.length === 0 ? (
Your cart is empty. Browse parcel data →
) : (
Place
Product
Record count
Price
{cart.map((it, i) => (
{it.place}
{it.product}
{it.records}
PARCEL DATA
${it.price.toFixed(2)}
remove(i)} width="17" height="17" viewBox="0 0 24 24" fill="none" stroke="#b0473c" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={{ cursor: "pointer" }}>
))}
Total
${total.toFixed(2)}
)}
{/* RIGHT — checkout */}
Check out
${total.toFixed(2)}
setBuyerField("name", value)} />
setBuyerField("email", value)} />
Payment details
Card and wallet payments are collected on Stripe's secure checkout page. LandAI never sees or stores card numbers.
Secure checkout by Stripe
You'll review the final total and pay on Stripe, then return to LandAI.
Our parcel data license agreement
tog("license")}>I accept the LandAI parcel data agreement and privacy policy
tog("sample")}>I have seen the sample file and coverage report on each county's store page
tog("emails")}>Sign me up for infrequent emails, including discounts on data updates
How we deliver the data
After checkout, you'll land on a confirmation page with download links for your purchased data. We'll also email those links to you for future reference. Download links stay active for 45 days.
{checkoutError && {checkoutError}
}
{checkoutBusy ? "STARTING CHECKOUT..." : "CONTINUE TO SECURE CHECKOUT"}
);
}
function CheckoutSuccessView({ onHome, onBrowse }) {
const sessionId = new URLSearchParams(window.location.search).get("session_id") || "";
return (
Payment received
Your LandAI data order is in.
Stripe confirmed the payment and LandAI has been notified. We are wiring automated delivery next; for now our team will follow up with access details for the parcel data you purchased.
{sessionId && (
Stripe session: {sessionId}
)}
Back to data store
LandAI home
);
}
// ---------- page ----------
function LandingView({ onBrowse }) {
return (
);
}
function DataStore() {
const initialRoute = readDataStoreRoute();
const [view, setView] = useState(initialRoute.view);
const [stateName, setStateName] = useState(initialRoute.stateName);
const [countyName, setCountyName] = useState(initialRoute.countyName);
const [supportDoc, setSupportDoc] = useState(initialRoute.supportDoc);
const [cart, setCart] = useState(() => readStoredDataStoreCart());
const [cartReturnRoute, setCartReturnRoute] = useState(initialRoute.view === "cart" ? normalizeStoreRoute({ view: "browse" }) : initialRoute);
const applyDataRoute = (route, replace = false) => {
const current = normalizeStoreRoute({ view, stateName, countyName, supportDoc });
const next = normalizeStoreRoute(route, { view, stateName, countyName, supportDoc });
if (next.view === "cart" && current.view !== "cart") {
setCartReturnRoute(current);
} else if (next.view !== "cart" && next.view !== "checkoutSuccess") {
setCartReturnRoute(next);
}
setView(next.view);
setStateName(next.stateName);
setCountyName(next.countyName);
setSupportDoc(next.supportDoc);
const path = dataStorePath(next.view, next.stateName, next.countyName, next.supportDoc);
if (window.location.pathname !== path) {
window.history[replace ? "replaceState" : "pushState"]({ dataStoreView: next.view }, "", path);
}
window.scrollTo(0, 0);
};
useEffect(() => {
const syncFromPath = () => {
const next = readDataStoreRoute();
setView(next.view);
setStateName(next.stateName);
setCountyName(next.countyName);
setSupportDoc(next.supportDoc);
if (next.view !== "cart" && next.view !== "checkoutSuccess") {
setCartReturnRoute(next);
}
};
const route = readDataStoreRoute();
const canonicalPath = dataStorePath(route.view, route.stateName, route.countyName, route.supportDoc);
if (window.location.pathname !== canonicalPath) {
window.history.replaceState({ dataStoreView: route.view }, "", canonicalPath);
}
window.addEventListener("popstate", syncFromPath);
return () => window.removeEventListener("popstate", syncFromPath);
}, []);
useEffect(() => {
writeStoredDataStoreCart(cart);
}, [cart]);
useEffect(() => {
const syncStoredCart = (event) => {
if (event.key === DATA_STORE_CART_STORAGE_KEY) setCart(readStoredDataStoreCart());
};
window.addEventListener("storage", syncStoredCart);
return () => window.removeEventListener("storage", syncStoredCart);
}, []);
useEffect(() => {
if (view === "checkoutSuccess") setCart([]);
}, [view]);
const browse = () => applyDataRoute({ view: "browse" });
const home = () => applyDataRoute({ view: "landing" });
const openState = (s) => applyDataRoute({ view: "state", stateName: s });
const openCounty = (c, s = stateName) => applyDataRoute({ view: "browseCounty", stateName: s, countyName: c });
const openSupport = (d) => applyDataRoute({ view: "support", supportDoc: d });
const openCoverage = () => applyDataRoute({ view: "coverage" });
const backToState = () => applyDataRoute({ view: "state" });
const backFromCart = () => applyDataRoute(cartReturnRoute && cartReturnRoute.view !== "cart" ? cartReturnRoute : { view: "browse" });
const addItem = (item) => setCart(c => c.some(x => x.place === item.place && x.product === item.product) ? c : [...c, item]);
const stateAbbr = (stateCodeForName(stateName) || "").toUpperCase();
const buyState = async () => {
let records = "Current coverage";
let supportedCount = 0;
try {
const geojson = await loadDataStoreCoverageGeoJSON();
const parcelTotal = (geojson?.features || []).reduce((sum, feature) => {
const fips = countyFipsFromFeature(feature);
const featureStateName = stateNameForCountyFips(fips) || feature?.properties?.STATE_NAME || "";
if (slugify(featureStateName) !== slugify(stateName)) return sum;
if (!dataStoreCountyIsSupported(feature)) return sum;
supportedCount += 1;
const meta = dataStoreCountyMetadataFromFeature(feature);
return sum + (meta.parcelCount || 0);
}, 0);
if (parcelTotal > 0) records = parcelTotal.toLocaleString();
} catch (err) {
console.warn("[data-store-state] State cart record count unavailable", err);
}
if (supportedCount <= 0) {
window.alert("Statewide data is not available for this state yet.");
return;
}
addItem({
type: "state",
place: stateName,
stateName,
stateCode: stateAbbr,
supportedCountyCount: supportedCount,
product: "Statewide parcel data",
records,
price: supportedCount * STATE_STORE_PRICE_PER_SUPPORTED_COUNTY,
});
applyDataRoute({ view: "cart" });
};
const addCounty = (c, price, records, options = {}) => {
const format = options.format || INCLUDED_FORMAT_LABEL;
const addons = options.addons || {};
addItem({
type: "county",
place: `${c}, ${stateAbbr}`.replace(", ,", ","),
countyName: c,
stateName,
stateCode: stateAbbr,
format,
addons,
apiAccess: options.apiAccess === true,
product: `County parcel data · ${format}${options.apiAccess === true ? " · API request" : ""}`,
records,
price,
});
applyDataRoute({ view: "cart" });
};
const openCart = () => applyDataRoute({ view: "cart" });
let content;
if (view === "landing") content =
;
else if (view === "state") content =
;
else if (view === "coverage") content =
;
else if (view === "county") content =
;
else if (view === "support") content =
;
else if (view === "cart") content =
;
else if (view === "checkoutSuccess") content =
;
else if (view === "browseCounty") content =
;
else content =
;
return (
<>
{content}
);
}
window.DataStore = DataStore;
})();