wenmar-open 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wenmar Pro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,190 @@
 # wenmar-open
 
-Client for Wenmar Open, the free vehicle data API for auto repair shops. Placeholder: the first release is in development.
+A typed client for the [Wenmar Open](https://open.wenmarpro.com) API: VIN decoding and a year, make, model, trim and engine catalog for auto repair shops. The API needs no key and no account.
 
-By [Wenmar Pro](https://wenmarpro.com).
+- No dependencies. It uses the platform's `fetch`.
+- Runs in Node 20 and later, browsers, Cloudflare Workers, Deno and Bun.
+- Types are generated from the API's OpenAPI description.
+
+```bash
+npm install wenmar-open
+```
+
+## Decode a VIN
+
+```ts
+import { WenmarOpen } from "wenmar-open";
+
+const open = new WenmarOpen();
+
+const vehicle = await open.decodeVin("KM8K2CAB4PU001140");
+console.log(vehicle.year, vehicle.make, vehicle.model, vehicle.trim);
+// 2023 Hyundai Kona SE
+console.log(vehicle.engine?.label, vehicle.drivetrain, vehicle.safety?.tpms);
+```
+
+Spaces, dashes and lowercase letters in the VIN are accepted. A field the data does not have is left out, so every field except `vin`, `valid`, `check_digit`, `manufacturer`, `plant` and `warnings` may be `undefined`.
+
+A wrong check digit is not an error. The decode comes back with `valid: false` and a warning, because many genuine VINs from outside North America fail the check:
+
+```ts
+import { WenmarOpen } from "wenmar-open";
+
+const vehicle = await new WenmarOpen().decodeVin("KM8K2CAB0PU001140");
+if (!vehicle.valid) {
+  for (const warning of vehicle.warnings) {
+    console.log(warning.code, warning.message, warning.suggestions);
+  }
+}
+```
+
+If you know the model year, pass it: `open.decodeVin(vin, { year: 2023 })`.
+
+## Errors
+
+Every method throws a `WenmarOpenError`. It has the API's `code`, `message` and `details`, and the HTTP `status`.
+
+```ts
+import { WenmarOpen, WenmarOpenError } from "wenmar-open";
+
+const open = new WenmarOpen();
+
+try {
+  await open.decodeVin("KM8K2CAB4PUO01140"); // a letter O where a zero belongs
+} catch (error) {
+  if (!(error instanceof WenmarOpenError)) throw error;
+  if (error.code === "invalid_vin") {
+    console.log(error.message); // what is wrong with it
+    console.log(error.details.suggestions); // VINs you may have meant
+  } else if (error.code === "not_found") {
+    console.log("No manufacturer is registered for this VIN.");
+  } else if (error.code === "rate_limited" || error.code === "unavailable") {
+    console.log(`Try again in ${error.retryAfter ?? 60} seconds.`);
+  } else {
+    throw error;
+  }
+}
+```
+
+| `code` | `status` | Meaning |
+|---|---|---|
+| `invalid_vin` | 400 | Wrong length or characters. `details.suggestions` lists likely corrections. |
+| `validation_failed` | 400 | A parameter is missing or wrong. `details.field` names it. |
+| `not_found` | 404 | No manufacturer for the VIN, or no vehicle with that id. |
+| `rate_limited` | 429 | Over 600 requests a minute from one address. `retryAfter` is in seconds. |
+| `unavailable` | 503 | The server is busy. `retryAfter` is in seconds. |
+| `internal_error` | 500 | Something went wrong on the server. |
+| `timeout` | none | No complete answer within `timeoutMs`. |
+| `aborted` | none | Your `signal` was aborted. |
+| `network` | none | The request could not be sent. `cause` has the reason. |
+| `bad_response` | any | Something answered, but not the API: a proxy's error page, a sign-in page. |
+
+The API may add codes. Treat a code you do not know as a failure.
+
+The client does not retry. If you retry, do it only for `rate_limited`, `unavailable`, `timeout` and `network`, and wait `retryAfter` seconds when it is set.
+
+## Decode many VINs
+
+```ts
+import { WenmarOpen, isBatchError } from "wenmar-open";
+
+const open = new WenmarOpen();
+const vins = ["KM8K2CAB4PU001140", "1HGCM82633A004352", "NOT-A-VIN"];
+
+const items = await open.decodeVins(vins);
+items.forEach((item, index) => {
+  if (isBatchError(item)) {
+    console.log(vins[index], "failed:", item.error.code);
+  } else {
+    console.log(item.vin, item.year, item.make, item.model);
+  }
+});
+```
+
+A batch holds at most 50 VINs (`MAX_BATCH`). The answer has one item per VIN, in the order sent. One bad VIN does not fail the batch.
+
+## Choose a vehicle without a VIN
+
+Each step offers only what is valid for the steps before it.
+
+```ts
+import { WenmarOpen } from "wenmar-open";
+
+const open = new WenmarOpen();
+
+const years = await open.years(); // newest first
+const makes = await open.makes({ year: 2019 }); // popular makes first
+const models = await open.models({ make: "honda", year: 2019 });
+const trims = await open.submodels({ make: "honda", model: "civic", year: 2019 });
+const engines = await open.engines({ make: "honda", model: "civic", year: 2019, submodel: "si" });
+
+console.log(years[0], makes[0]?.name, models[0]?.name, trims[0]?.name, engines[0]?.label);
+```
+
+`make` and `model` take a name, an alias or an id: `Chevrolet`, `chevy` and `chevrolet` are the same make. `term` filters any step by what someone has typed so far, for autocomplete: `open.makes({ term: "che" })`.
+
+Free text works too, and every vehicle has an id you can store:
+
+```ts
+import { WenmarOpen } from "wenmar-open";
+
+const open = new WenmarOpen();
+
+const [best] = await open.search({ q: "2019 civic si" });
+console.log(best?.id, best?.summary);
+
+const same = await open.vehicle("2019_honda_civic_si");
+console.log(same.summary);
+```
+
+A decoded VIN carries the same ids in `catalog`, so a VIN can fill in a vehicle form: `vehicle.catalog?.entry.id`.
+
+## Options
+
+```ts
+import { WenmarOpen } from "wenmar-open";
+
+const open = new WenmarOpen({
+  baseUrl: "http://localhost:3000", // your own server; default https://open.wenmarpro.com
+  timeoutMs: 5_000, // default 10,000; 0 for no limit
+});
+
+// Per request: a time limit, and a signal to cancel with.
+const controller = new AbortController();
+const makes = await open.makes({ term: "ho" }, { signal: controller.signal, timeoutMs: 2_000 });
+console.log(makes.length);
+```
+
+`fetch` replaces the platform's `fetch`, for a Workers service binding or a test:
+
+```ts
+import { WenmarOpen } from "wenmar-open";
+import type { FetchLike } from "wenmar-open";
+
+const logged: FetchLike = async (url, init) => {
+  console.log(init.method, url);
+  return fetch(url, init);
+};
+const open = new WenmarOpen({ fetch: logged });
+console.log((await open.meta()).data_version);
+```
+
+## Caching and limits
+
+Answers change only when the data does, about once a month. `open.meta()` returns the `data_version`; anything you cache can be kept until it changes. In a browser the HTTP cache already does this.
+
+One address may make 600 requests a minute. A server that calls the API for many users shares one address, so cache catalog answers there. To decode a list of VINs, use `decodeVins`: a batch of 50 counts as one request.
+
+## CommonJS
+
+The package is an ES module. `require("wenmar-open")` works in Node 20.19 and later and in Node 22.12 and later. In older Node 20 releases use `await import("wenmar-open")`.
+
+## Types
+
+Every response type is exported: `VinDecode`, `Entry`, `Make`, `Model`, `Submodel`, `EngineOption`, `Meta`, `BatchItem`, `ErrorBody`. The generated `paths`, `operations` and `components` types are exported as well.
+
+The API only ever adds fields and endpoints. A response may carry fields this version's types do not name; they are passed through untouched.
+
+## License
+
+MIT. Vehicle data comes from NHTSA's vPIC and is described in the repository's [NOTICE.md](https://github.com/wenmar-pro/wenmar-open/blob/main/NOTICE.md).

package/dist/client.d.ts

@@ -0,0 +1,84 @@
+import type { BatchItem, EngineOption, EnginesQuery, Entry, ErrorBody, Make, MakesQuery, Meta, Model, ModelsQuery, SearchQuery, Submodel, SubmodelsQuery, VinDecode, YearsQuery } from "./types.js";
+/** The hosted API. */
+export declare const DEFAULT_BASE_URL = "https://open.wenmarpro.com";
+/** How long a request may take before it fails with `timeout`. */
+export declare const DEFAULT_TIMEOUT_MS = 10000;
+/** The most VINs the API decodes in one batch. */
+export declare const MAX_BATCH = 50;
+/** What the client asks of a `fetch`: the part of the standard it uses. */
+export interface FetchInit {
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+    signal: AbortSignal;
+}
+/** What the client reads of a response. */
+export interface FetchResponse {
+    readonly status: number;
+    readonly headers: {
+        get(name: string): string | null;
+    };
+    text(): Promise<string>;
+}
+/** A `fetch`. The platform's own fits; so does a Workers service binding's. */
+export type FetchLike = (url: string, init: FetchInit) => Promise<FetchResponse>;
+export interface ClientOptions {
+    /**
+     * Where the API is. Default `https://open.wenmarpro.com`. A path is kept,
+     * so `https://example.com/open` reaches `https://example.com/open/v1/...`.
+     */
+    baseUrl?: string;
+    /**
+     * Milliseconds a request may take, the body included. Default 10,000.
+     * `0` means no limit.
+     */
+    timeoutMs?: number;
+    /** Used instead of the platform's `fetch`. */
+    fetch?: FetchLike;
+}
+/** What every method accepts last. */
+export interface RequestOptions {
+    /** Aborting it fails the request with the code `aborted`. */
+    signal?: AbortSignal;
+    /** Overrides the client's `timeoutMs` for this request. */
+    timeoutMs?: number;
+}
+export interface DecodeOptions extends RequestOptions {
+    /** Use this model year instead of working it out from the VIN. */
+    year?: number;
+}
+/** Whether an item of a batch is the error for its VIN and not a decode. */
+export declare function isBatchError(item: BatchItem): item is ErrorBody;
+/** A client for the Wenmar Open API. It keeps no state between requests. */
+export declare class WenmarOpen {
+    #private;
+    readonly baseUrl: string;
+    readonly timeoutMs: number;
+    constructor(options?: ClientOptions);
+    /** Decode one VIN. Spaces, dashes and lowercase are accepted. */
+    decodeVin(vin: string, options?: DecodeOptions): Promise<VinDecode>;
+    /**
+     * Decode up to 50 VINs. The answer has one item per VIN, in order: a
+     * decode, or the error a single request for that VIN would have given.
+     * Tell them apart with `isBatchError`.
+     */
+    decodeVins(vins: readonly string[], options?: RequestOptions): Promise<BatchItem[]>;
+    /** Model years, newest first. */
+    years(query?: YearsQuery, options?: RequestOptions): Promise<number[]>;
+    /** Makes, popular ones first and the rest by name. */
+    makes(query?: MakesQuery, options?: RequestOptions): Promise<Make[]>;
+    /** Models of a make, by name. An unknown make has no models. */
+    models(query: ModelsQuery, options?: RequestOptions): Promise<Model[]>;
+    /** Submodels of a model year: trims, or series where there are no trims. */
+    submodels(query: SubmodelsQuery, options?: RequestOptions): Promise<Submodel[]>;
+    /** The same as `submodels`, under the name most people use. */
+    trims(query: SubmodelsQuery, options?: RequestOptions): Promise<Submodel[]>;
+    /** Engines of a model year, in short form. */
+    engines(query: EnginesQuery, options?: RequestOptions): Promise<EngineOption[]>;
+    /** Catalog entries for free text such as `2019 civic si`, best first. */
+    search(query: SearchQuery, options?: RequestOptions): Promise<Entry[]>;
+    /** One catalog entry by its id, such as `2019_honda_civic_si`. */
+    vehicle(id: string, options?: RequestOptions): Promise<Entry>;
+    /** The data version, the vPIC release it came from, and the build time. */
+    meta(options?: RequestOptions): Promise<Meta>;
+}

package/dist/client.js

@@ -0,0 +1,205 @@
+import { WenmarOpenError, parseRetryAfter } from "./errors.js";
+/** The hosted API. */
+export const DEFAULT_BASE_URL = "https://open.wenmarpro.com";
+/** How long a request may take before it fails with `timeout`. */
+export const DEFAULT_TIMEOUT_MS = 10_000;
+/** The most VINs the API decodes in one batch. */
+export const MAX_BATCH = 50;
+function queryString(query) {
+    const params = new URLSearchParams();
+    for (const [name, value] of Object.entries((query ?? {}))) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        params.append(name, String(value));
+    }
+    const text = params.toString();
+    return text === "" ? "" : `?${text}`;
+}
+/**
+ * One path segment. A URL treats `.` and `..` as directions, not names, even
+ * when they are percent-encoded, so they are refused here: sent, they would
+ * reach a different address than the one meant.
+ */
+function segment(field, value) {
+    const text = String(value).trim();
+    if (text === "" || text === "." || text === "..") {
+        throw new WenmarOpenError({
+            code: "validation_failed",
+            message: `${field} is required`,
+            details: { field },
+        });
+    }
+    return encodeURIComponent(text);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Whether an item of a batch is the error for its VIN and not a decode. */
+export function isBatchError(item) {
+    return isRecord(item.error);
+}
+/** A client for the Wenmar Open API. It keeps no state between requests. */
+export class WenmarOpen {
+    baseUrl;
+    timeoutMs;
+    #fetch;
+    constructor(options = {}) {
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        // The platform's fetch is looked up at each call, not kept.
+        this.#fetch = options.fetch ?? ((url, init) => fetch(url, init));
+    }
+    /** Decode one VIN. Spaces, dashes and lowercase are accepted. */
+    async decodeVin(vin, options = {}) {
+        const path = `/v1/vin/${segment("vin", vin)}${queryString({ year: options.year })}`;
+        return this.#request("GET", path, undefined, options);
+    }
+    /**
+     * Decode up to 50 VINs. The answer has one item per VIN, in order: a
+     * decode, or the error a single request for that VIN would have given.
+     * Tell them apart with `isBatchError`.
+     */
+    async decodeVins(vins, options = {}) {
+        if (vins.length > MAX_BATCH) {
+            throw new WenmarOpenError({
+                code: "validation_failed",
+                message: `a batch holds at most ${MAX_BATCH} VINs`,
+                details: { field: "vins", max: MAX_BATCH, received: vins.length },
+            });
+        }
+        return this.#request("POST", "/v1/vin/batch", { vins }, options);
+    }
+    /** Model years, newest first. */
+    async years(query = {}, options = {}) {
+        return this.#request("GET", `/v1/vehicles/years${queryString(query)}`, undefined, options);
+    }
+    /** Makes, popular ones first and the rest by name. */
+    async makes(query = {}, options = {}) {
+        return this.#request("GET", `/v1/vehicles/makes${queryString(query)}`, undefined, options);
+    }
+    /** Models of a make, by name. An unknown make has no models. */
+    async models(query, options = {}) {
+        return this.#request("GET", `/v1/vehicles/models${queryString(query)}`, undefined, options);
+    }
+    /** Submodels of a model year: trims, or series where there are no trims. */
+    async submodels(query, options = {}) {
+        return this.#request("GET", `/v1/vehicles/submodels${queryString(query)}`, undefined, options);
+    }
+    /** The same as `submodels`, under the name most people use. */
+    async trims(query, options = {}) {
+        return this.#request("GET", `/v1/vehicles/trims${queryString(query)}`, undefined, options);
+    }
+    /** Engines of a model year, in short form. */
+    async engines(query, options = {}) {
+        return this.#request("GET", `/v1/vehicles/engines${queryString(query)}`, undefined, options);
+    }
+    /** Catalog entries for free text such as `2019 civic si`, best first. */
+    async search(query, options = {}) {
+        return this.#request("GET", `/v1/vehicles/search${queryString(query)}`, undefined, options);
+    }
+    /** One catalog entry by its id, such as `2019_honda_civic_si`. */
+    async vehicle(id, options = {}) {
+        return this.#request("GET", `/v1/vehicles/${segment("id", id)}`, undefined, options);
+    }
+    /** The data version, the vPIC release it came from, and the build time. */
+    async meta(options = {}) {
+        return this.#request("GET", "/v1/meta", undefined, options);
+    }
+    async #request(method, path, body, options) {
+        const caller = options.signal;
+        if (caller?.aborted) {
+            throw new WenmarOpenError({ code: "aborted", message: "The request was aborted.", cause: caller.reason });
+        }
+        const timeoutMs = options.timeoutMs ?? this.timeoutMs;
+        const controller = new AbortController();
+        let timedOut = false;
+        const timer = timeoutMs > 0
+            ? setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+            }, timeoutMs)
+            : undefined;
+        const onAbort = () => controller.abort();
+        caller?.addEventListener("abort", onAbort, { once: true });
+        const headers = { Accept: "application/json" };
+        const init = { method, headers, signal: controller.signal };
+        if (body !== undefined) {
+            headers["Content-Type"] = "application/json";
+            init.body = JSON.stringify(body);
+        }
+        let status;
+        let retryAfter;
+        let text;
+        try {
+            // Called as a plain function, never as a method of this object: some
+            // runtimes refuse a `fetch` whose `this` is not the global object.
+            const send = this.#fetch;
+            const response = await send(`${this.baseUrl}${path}`, init);
+            status = response.status;
+            retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+            // The time limit covers the body: it is read before the timer stops.
+            text = await response.text();
+        }
+        catch (cause) {
+            if (timedOut) {
+                throw new WenmarOpenError({
+                    code: "timeout",
+                    message: `No answer within ${timeoutMs} ms.`,
+                    details: { timeout_ms: timeoutMs },
+                    cause,
+                });
+            }
+            if (caller?.aborted) {
+                throw new WenmarOpenError({ code: "aborted", message: "The request was aborted.", cause });
+            }
+            throw new WenmarOpenError({
+                code: "network",
+                message: `The API at ${this.baseUrl} could not be reached.`,
+                cause,
+            });
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            caller?.removeEventListener("abort", onAbort);
+        }
+        let parsed;
+        let isJson = true;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            isJson = false;
+        }
+        if (status >= 200 && status < 300) {
+            if (!isJson) {
+                throw new WenmarOpenError({
+                    code: "bad_response",
+                    message: `The answer from ${this.baseUrl} is not JSON. Something other than the API may have answered.`,
+                    status,
+                });
+            }
+            return parsed;
+        }
+        const error = isRecord(parsed) ? parsed["error"] : undefined;
+        if (isRecord(error) && typeof error["code"] === "string" && typeof error["message"] === "string") {
+            const details = isRecord(error["details"]) ? error["details"] : {};
+            // The header is what the API promises. The body's copy is used when a
+            // proxy in between dropped the header.
+            const inBody = details["retry_after"];
+            throw new WenmarOpenError({
+                code: error["code"],
+                message: error["message"],
+                details,
+                status,
+                retryAfter: retryAfter ?? (typeof inBody === "number" ? inBody : undefined),
+            });
+        }
+        throw new WenmarOpenError({
+            code: "bad_response",
+            message: `The server answered ${status} without the API's error body. A proxy in front of the API may have answered.`,
+            status,
+            retryAfter,
+        });
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,46 @@
+/** The codes the API answers with. */
+export type ApiErrorCode = "invalid_vin" | "validation_failed" | "not_found" | "method_not_allowed" | "payload_too_large" | "uri_too_long" | "rate_limited" | "unavailable" | "internal_error";
+/**
+ * The codes this client adds for failures that never reached the API or
+ * did not come from it.
+ *
+ * - `network`: the request could not be sent or the answer could not be read.
+ * - `timeout`: no complete answer within `timeoutMs`.
+ * - `aborted`: the caller's `signal` was aborted.
+ * - `bad_response`: something answered, but not with the API's JSON. A proxy's
+ *   error page and a sign-in page from a captive portal both end up here.
+ */
+export type ClientErrorCode = "network" | "timeout" | "aborted" | "bad_response";
+/**
+ * Every code known when this version was published. The API may add codes,
+ * so `code` is typed to accept any string while still completing these.
+ */
+export type ErrorCode = ApiErrorCode | ClientErrorCode | (string & {});
+export interface WenmarOpenErrorInit {
+    code: ErrorCode;
+    message: string;
+    details?: Record<string, unknown> | undefined;
+    status?: number | undefined;
+    retryAfter?: number | undefined;
+    cause?: unknown;
+}
+/** The one error every method of the client throws. */
+export declare class WenmarOpenError extends Error {
+    /** A stable code to branch on. */
+    readonly code: ErrorCode;
+    /** The HTTP status, or `undefined` when there was no HTTP answer. */
+    readonly status: number | undefined;
+    /** More about the error, as the API sent it. Empty when there is nothing. */
+    readonly details: Record<string, unknown>;
+    /**
+     * Seconds to wait before trying again, from the `Retry-After` header of a
+     * `429` or `503`. `undefined` when the answer did not say.
+     */
+    readonly retryAfter: number | undefined;
+    constructor(init: WenmarOpenErrorInit);
+}
+/**
+ * Reads a `Retry-After` header: a number of seconds, or an HTTP date.
+ * Returns whole seconds, never negative, or `undefined` if it is neither.
+ */
+export declare function parseRetryAfter(header: string | null, now?: number): number | undefined;

package/dist/errors.js

@@ -0,0 +1,37 @@
+/** The one error every method of the client throws. */
+export class WenmarOpenError extends Error {
+    /** A stable code to branch on. */
+    code;
+    /** The HTTP status, or `undefined` when there was no HTTP answer. */
+    status;
+    /** More about the error, as the API sent it. Empty when there is nothing. */
+    details;
+    /**
+     * Seconds to wait before trying again, from the `Retry-After` header of a
+     * `429` or `503`. `undefined` when the answer did not say.
+     */
+    retryAfter;
+    constructor(init) {
+        super(init.message, init.cause === undefined ? undefined : { cause: init.cause });
+        this.name = "WenmarOpenError";
+        this.code = init.code;
+        this.status = init.status;
+        this.details = init.details ?? {};
+        this.retryAfter = init.retryAfter;
+    }
+}
+/**
+ * Reads a `Retry-After` header: a number of seconds, or an HTTP date.
+ * Returns whole seconds, never negative, or `undefined` if it is neither.
+ */
+export function parseRetryAfter(header, now = Date.now()) {
+    if (header === null)
+        return undefined;
+    const text = header.trim();
+    if (/^\d+$/.test(text))
+        return Number(text);
+    const date = Date.parse(text);
+    if (Number.isNaN(date))
+        return undefined;
+    return Math.max(0, Math.ceil((date - now) / 1000));
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, MAX_BATCH, WenmarOpen, isBatchError, } from "./client.js";
+export type { ClientOptions, DecodeOptions, FetchInit, FetchLike, FetchResponse, RequestOptions, } from "./client.js";
+export { WenmarOpenError } from "./errors.js";
+export type { ApiErrorCode, ClientErrorCode, ErrorCode, WenmarOpenErrorInit } from "./errors.js";
+export type { BatchItem, CheckDigit, Engine, EngineOption, EnginesQuery, Entry, ErrorBody, Make, MakesQuery, Manufacturer, Meta, Model, ModelsQuery, Plant, Safety, SearchQuery, Selection, Submodel, SubmodelsQuery, VinDecode, Warning, YearsQuery, } from "./types.js";
+export type { components, operations, paths } from "./schema.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, MAX_BATCH, WenmarOpen, isBatchError, } from "./client.js";
+export { WenmarOpenError } from "./errors.js";