@voyantjs/products-react 0.1.1

package/README.md

@@ -0,0 +1,36 @@
+# @voyantjs/products-react
+
+React runtime package for Voyant products. Provides the shared products provider, typed fetch client, query keys, and TanStack Query hooks that power product-focused frontend experiences.
+
+## Install
+
+```bash
+pnpm add @voyantjs/products-react @voyantjs/products @tanstack/react-query react react-dom zod
+```
+
+## Usage
+
+```tsx
+import { VoyantProductsProvider, useProducts } from "@voyantjs/products-react"
+
+function App() {
+  return (
+    <VoyantProductsProvider baseUrl="/api">
+      <ProductsList />
+    </VoyantProductsProvider>
+  )
+}
+
+function ProductsList() {
+  const { data } = useProducts()
+  return <>{data?.data.map((product) => <div key={product.id}>{product.name}</div>)}</>
+}
+```
+
+## Relationship To The Registry
+
+`@voyantjs/products-react` is the runtime layer. Installable product UI blocks should come from the Voyant shadcn registry and depend on this package for hooks, client state, and provider wiring.
+
+## License
+
+FSL-1.1-Apache-2.0

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+export type VoyantFetcher = (url: string, init?: RequestInit) => Promise<Response>;
+export declare const defaultFetcher: VoyantFetcher;
+export declare class VoyantApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+export interface FetchWithValidationOptions {
+    baseUrl: string;
+    fetcher: VoyantFetcher;
+}
+export declare function fetchWithValidation<TOut>(path: string, schema: z.ZodType<TOut>, options: FetchWithValidationOptions, init?: RequestInit): Promise<TOut>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;AAElF,eAAO,MAAM,cAAc,EAAE,aACoB,CAAA;AAEjD,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;gBAEV,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;CAM3D;AAaD,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,aAAa,CAAA;CACvB;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAC5C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EACvB,OAAO,EAAE,0BAA0B,EACnC,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/dist/client.js

@@ -0,0 +1,59 @@
+export const defaultFetcher = (url, init) => fetch(url, { credentials: "include", ...init });
+export class VoyantApiError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.name = "VoyantApiError";
+        this.status = status;
+        this.body = body;
+    }
+}
+function extractErrorMessage(status, statusText, body) {
+    if (typeof body === "object" && body !== null && "error" in body) {
+        const err = body.error;
+        if (typeof err === "string")
+            return err;
+        if (typeof err === "object" && err !== null && "message" in err) {
+            return String(err.message);
+        }
+    }
+    return `Voyant API error: ${status} ${statusText}`;
+}
+export async function fetchWithValidation(path, schema, options, init) {
+    const url = joinUrl(options.baseUrl, path);
+    const headers = new Headers(init?.headers);
+    if (init?.body !== undefined && !headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+    }
+    const response = await options.fetcher(url, { ...init, headers });
+    if (!response.ok) {
+        const body = await safeJson(response);
+        throw new VoyantApiError(extractErrorMessage(response.status, response.statusText, body), response.status, body);
+    }
+    if (response.status === 204) {
+        return schema.parse(undefined);
+    }
+    const body = await safeJson(response);
+    const parsed = schema.safeParse(body);
+    if (!parsed.success) {
+        throw new VoyantApiError(`Voyant API response failed validation: ${parsed.error.message}`, response.status, body);
+    }
+    return parsed.data;
+}
+async function safeJson(response) {
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function joinUrl(baseUrl, path) {
+    const trimmedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const trimmedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${trimmedBase}${trimmedPath}`;
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./use-product.js";
+export * from "./use-product-mutation.js";
+export * from "./use-product-types.js";
+export * from "./use-products.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,2BAA2B,CAAA;AACzC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA"}

package/dist/hooks/index.js

@@ -0,0 +1,4 @@
+export * from "./use-product.js";
+export * from "./use-product-mutation.js";
+export * from "./use-product-types.js";
+export * from "./use-products.js";

package/dist/hooks/use-product-mutation.d.ts

@@ -0,0 +1,79 @@
+export interface CreateProductInput {
+    name: string;
+    status?: "draft" | "active" | "archived";
+    description?: string | null;
+    bookingMode?: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+    capacityMode?: "free_sale" | "limited" | "on_request";
+    timezone?: string | null;
+    visibility?: "public" | "private" | "hidden";
+    activated?: boolean;
+    reservationTimeoutMinutes?: number | null;
+    sellCurrency: string;
+    sellAmountCents?: number | null;
+    costAmountCents?: number | null;
+    marginPercent?: number | null;
+    facilityId?: string | null;
+    productTypeId?: string | null;
+    startDate?: string | null;
+    endDate?: string | null;
+    pax?: number | null;
+    tags?: string[];
+}
+export type UpdateProductInput = Partial<CreateProductInput>;
+export declare function useProductMutation(): {
+    create: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        name: string;
+        status: "draft" | "active" | "archived";
+        description: string | null;
+        bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+        capacityMode: "free_sale" | "limited" | "on_request";
+        timezone: string | null;
+        visibility: "public" | "private" | "hidden";
+        activated: boolean;
+        reservationTimeoutMinutes: number | null;
+        sellCurrency: string;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        marginPercent: number | null;
+        facilityId: string | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        productTypeId: string | null;
+        tags: string[];
+        createdAt: string;
+        updatedAt: string;
+    }, Error, CreateProductInput, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        name: string;
+        status: "draft" | "active" | "archived";
+        description: string | null;
+        bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+        capacityMode: "free_sale" | "limited" | "on_request";
+        timezone: string | null;
+        visibility: "public" | "private" | "hidden";
+        activated: boolean;
+        reservationTimeoutMinutes: number | null;
+        sellCurrency: string;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        marginPercent: number | null;
+        facilityId: string | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        productTypeId: string | null;
+        tags: string[];
+        createdAt: string;
+        updatedAt: string;
+    }, Error, {
+        id: string;
+        input: UpdateProductInput;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string, unknown>;
+};
+//# sourceMappingURL=use-product-mutation.d.ts.map

package/dist/hooks/use-product-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-mutation.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAA;IACxC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,OAAO,CAAA;IACzF,YAAY,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,YAAY,CAAA;IACrD,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,UAAU,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAA;IAC5C,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,yBAAyB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzC,YAAY,EAAE,MAAM,CAAA;IACpB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAChB;AAED,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;AAI5D,wBAAgB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkBU,MAAM;eAAS,kBAAkB;;;;;EA+B5E"}

package/dist/hooks/use-product-mutation.js

@@ -0,0 +1,44 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { z } from "zod";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantProductsContext } from "../provider.js";
+import { productsQueryKeys } from "../query-keys.js";
+import { productSingleResponse } from "../schemas.js";
+const deleteResponseSchema = z.object({ success: z.boolean() });
+export function useProductMutation() {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const queryClient = useQueryClient();
+    const create = useMutation({
+        mutationFn: async (input) => {
+            const { data } = await fetchWithValidation("/v1/products", productSingleResponse, {
+                baseUrl,
+                fetcher,
+            }, { method: "POST", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.products() });
+        },
+    });
+    const update = useMutation({
+        mutationFn: async ({ id, input }) => {
+            const { data } = await fetchWithValidation(`/v1/products/${id}`, productSingleResponse, { baseUrl, fetcher }, { method: "PATCH", body: JSON.stringify(input) });
+            return data;
+        },
+        onSuccess: (data) => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.products() });
+            queryClient.setQueryData(productsQueryKeys.product(data.id), data);
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (id) => {
+            return fetchWithValidation(`/v1/products/${id}`, deleteResponseSchema, { baseUrl, fetcher }, { method: "DELETE" });
+        },
+        onSuccess: (_data, id) => {
+            void queryClient.invalidateQueries({ queryKey: productsQueryKeys.products() });
+            queryClient.removeQueries({ queryKey: productsQueryKeys.product(id) });
+        },
+    });
+    return { create, update, remove };
+}

package/dist/hooks/use-product-types.d.ts

@@ -0,0 +1,21 @@
+import { type ProductTypesListFilters } from "../query-keys.js";
+export interface UseProductTypesOptions extends ProductTypesListFilters {
+    enabled?: boolean;
+}
+export declare function useProductTypes(options?: UseProductTypesOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        name: string;
+        code: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        createdAt: string;
+        updatedAt: string;
+        metadata?: Record<string, unknown> | null | undefined;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-product-types.d.ts.map

package/dist/hooks/use-product-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-product-types.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product-types.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,uBAAuB,EAAqB,MAAM,kBAAkB,CAAA;AAGlF,MAAM,WAAW,sBAAuB,SAAQ,uBAAuB;IACrE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B;;;;;;;;;;;;;;;UAqBnE"}

package/dist/hooks/use-product-types.js

@@ -0,0 +1,27 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantProductsContext } from "../provider.js";
+import { productsQueryKeys } from "../query-keys.js";
+import { productTypeListResponse } from "../schemas.js";
+export function useProductTypes(options = {}) {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const { enabled = true, ...filters } = options;
+    return useQuery({
+        queryKey: productsQueryKeys.productTypesList(filters),
+        queryFn: () => {
+            const params = new URLSearchParams();
+            if (filters.active !== undefined)
+                params.set("active", String(filters.active));
+            if (filters.search)
+                params.set("search", filters.search);
+            if (filters.limit !== undefined)
+                params.set("limit", String(filters.limit));
+            if (filters.offset !== undefined)
+                params.set("offset", String(filters.offset));
+            const qs = params.toString();
+            return fetchWithValidation(`/v1/products/product-types${qs ? `?${qs}` : ""}`, productTypeListResponse, { baseUrl, fetcher });
+        },
+        enabled,
+    });
+}

package/dist/hooks/use-product.d.ts

@@ -0,0 +1,28 @@
+export interface UseProductOptions {
+    enabled?: boolean;
+}
+export declare function useProduct(id: string | undefined, options?: UseProductOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    name: string;
+    status: "draft" | "active" | "archived";
+    description: string | null;
+    bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+    capacityMode: "free_sale" | "limited" | "on_request";
+    timezone: string | null;
+    visibility: "public" | "private" | "hidden";
+    activated: boolean;
+    reservationTimeoutMinutes: number | null;
+    sellCurrency: string;
+    sellAmountCents: number | null;
+    costAmountCents: number | null;
+    marginPercent: number | null;
+    facilityId: string | null;
+    startDate: string | null;
+    endDate: string | null;
+    pax: number | null;
+    productTypeId: string | null;
+    tags: string[];
+    createdAt: string;
+    updatedAt: string;
+}, Error>;
+//# sourceMappingURL=use-product.d.ts.map

package/dist/hooks/use-product.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-product.d.ts","sourceRoot":"","sources":["../../src/hooks/use-product.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,GAAE,iBAAsB;;;;;;;;;;;;;;;;;;;;;;;UAgBjF"}

package/dist/hooks/use-product.js

@@ -0,0 +1,23 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantProductsContext } from "../provider.js";
+import { productsQueryKeys } from "../query-keys.js";
+import { productSingleResponse } from "../schemas.js";
+export function useProduct(id, options = {}) {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const { enabled = true } = options;
+    return useQuery({
+        queryKey: productsQueryKeys.product(id ?? ""),
+        queryFn: async () => {
+            if (!id)
+                throw new Error("useProduct requires an id");
+            const { data } = await fetchWithValidation(`/v1/products/${id}`, productSingleResponse, {
+                baseUrl,
+                fetcher,
+            });
+            return data;
+        },
+        enabled: enabled && Boolean(id),
+    });
+}

package/dist/hooks/use-products.d.ts

@@ -0,0 +1,34 @@
+import { type ProductsListFilters } from "../query-keys.js";
+export interface UseProductsOptions extends ProductsListFilters {
+    enabled?: boolean;
+}
+export declare function useProducts(options?: UseProductsOptions): import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        name: string;
+        status: "draft" | "active" | "archived";
+        description: string | null;
+        bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+        capacityMode: "free_sale" | "limited" | "on_request";
+        timezone: string | null;
+        visibility: "public" | "private" | "hidden";
+        activated: boolean;
+        reservationTimeoutMinutes: number | null;
+        sellCurrency: string;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        marginPercent: number | null;
+        facilityId: string | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        productTypeId: string | null;
+        tags: string[];
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+//# sourceMappingURL=use-products.d.ts.map

package/dist/hooks/use-products.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-products.d.ts","sourceRoot":"","sources":["../../src/hooks/use-products.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,mBAAmB,EAAqB,MAAM,kBAAkB,CAAA;AAG9E,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwB3D"}

package/dist/hooks/use-products.js

@@ -0,0 +1,38 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantProductsContext } from "../provider.js";
+import { productsQueryKeys } from "../query-keys.js";
+import { productListResponse } from "../schemas.js";
+export function useProducts(options = {}) {
+    const { baseUrl, fetcher } = useVoyantProductsContext();
+    const { enabled = true, ...filters } = options;
+    return useQuery({
+        queryKey: productsQueryKeys.productsList(filters),
+        queryFn: () => {
+            const params = new URLSearchParams();
+            if (filters.status)
+                params.set("status", filters.status);
+            if (filters.bookingMode)
+                params.set("bookingMode", filters.bookingMode);
+            if (filters.visibility)
+                params.set("visibility", filters.visibility);
+            if (filters.activated !== undefined)
+                params.set("activated", String(filters.activated));
+            if (filters.facilityId)
+                params.set("facilityId", filters.facilityId);
+            if (filters.search)
+                params.set("search", filters.search);
+            if (filters.limit !== undefined)
+                params.set("limit", String(filters.limit));
+            if (filters.offset !== undefined)
+                params.set("offset", String(filters.offset));
+            const qs = params.toString();
+            return fetchWithValidation(`/v1/products${qs ? `?${qs}` : ""}`, productListResponse, {
+                baseUrl,
+                fetcher,
+            });
+        },
+        enabled,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { fetchWithValidation, defaultFetcher, VoyantApiError, type VoyantFetcher, } from "./client.js";
+export { VoyantProductsProvider, useVoyantProductsContext, type VoyantProductsContextValue, type VoyantProductsProviderProps, } from "./provider.js";
+export { productsQueryKeys } from "./query-keys.js";
+export * from "./schemas.js";
+export * from "./hooks/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,KAAK,aAAa,GACnB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,sBAAsB,EACtB,wBAAwB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,GACjC,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACnD,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { fetchWithValidation, defaultFetcher, VoyantApiError, } from "./client.js";
+export { VoyantProductsProvider, useVoyantProductsContext, } from "./provider.js";
+export { productsQueryKeys } from "./query-keys.js";
+export * from "./schemas.js";
+export * from "./hooks/index.js";

package/dist/provider.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+import { type VoyantFetcher } from "./client.js";
+export interface VoyantProductsContextValue {
+    baseUrl: string;
+    fetcher: VoyantFetcher;
+}
+export interface VoyantProductsProviderProps {
+    baseUrl: string;
+    fetcher?: VoyantFetcher;
+    children: ReactNode;
+}
+export declare function VoyantProductsProvider({ baseUrl, fetcher, children, }: VoyantProductsProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useVoyantProductsContext(): VoyantProductsContextValue;
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,SAAS,EAAuB,MAAM,OAAO,CAAA;AAE1E,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhE,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,aAAa,CAAA;CACvB;AAID,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,QAAQ,EAAE,SAAS,CAAA;CACpB;AAED,wBAAgB,sBAAsB,CAAC,EACrC,OAAO,EACP,OAAO,EACP,QAAQ,GACT,EAAE,2BAA2B,2CAM7B;AAED,wBAAgB,wBAAwB,IAAI,0BAA0B,CAQrE"}

package/dist/provider.js

@@ -0,0 +1,16 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from "react";
+import { defaultFetcher } from "./client.js";
+const VoyantProductsContext = createContext(null);
+export function VoyantProductsProvider({ baseUrl, fetcher, children, }) {
+    const value = useMemo(() => ({ baseUrl, fetcher: fetcher ?? defaultFetcher }), [baseUrl, fetcher]);
+    return _jsx(VoyantProductsContext.Provider, { value: value, children: children });
+}
+export function useVoyantProductsContext() {
+    const context = useContext(VoyantProductsContext);
+    if (!context) {
+        throw new Error('useVoyantProductsContext must be used inside <VoyantProductsProvider>. Wrap your app with <VoyantProductsProvider baseUrl="/api" />.');
+    }
+    return context;
+}

package/dist/query-keys.d.ts

@@ -0,0 +1,26 @@
+export interface ProductsListFilters {
+    status?: string | undefined;
+    bookingMode?: string | undefined;
+    visibility?: string | undefined;
+    activated?: boolean | undefined;
+    facilityId?: string | undefined;
+    search?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}
+export interface ProductTypesListFilters {
+    active?: boolean | undefined;
+    search?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}
+export declare const productsQueryKeys: {
+    readonly all: readonly ["voyant", "products"];
+    readonly products: () => readonly ["voyant", "products", "products"];
+    readonly productsList: (filters: ProductsListFilters) => readonly ["voyant", "products", "products", "list", ProductsListFilters];
+    readonly product: (id: string) => readonly ["voyant", "products", "products", "detail", string];
+    readonly productTypes: () => readonly ["voyant", "products", "product-types"];
+    readonly productTypesList: (filters: ProductTypesListFilters) => readonly ["voyant", "products", "product-types", "list", ProductTypesListFilters];
+    readonly productType: (id: string) => readonly ["voyant", "products", "product-types", "detail", string];
+};
+//# sourceMappingURL=query-keys.d.ts.map

package/dist/query-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-keys.d.ts","sourceRoot":"","sources":["../src/query-keys.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC/B,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC5B;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC5B;AAED,eAAO,MAAM,iBAAiB;;;qCAIJ,mBAAmB;2BAE7B,MAAM;;yCAGQ,uBAAuB;+BAEjC,MAAM;CAChB,CAAA"}

package/dist/query-keys.js

@@ -0,0 +1,9 @@
+export const productsQueryKeys = {
+    all: ["voyant", "products"],
+    products: () => [...productsQueryKeys.all, "products"],
+    productsList: (filters) => [...productsQueryKeys.products(), "list", filters],
+    product: (id) => [...productsQueryKeys.products(), "detail", id],
+    productTypes: () => [...productsQueryKeys.all, "product-types"],
+    productTypesList: (filters) => [...productsQueryKeys.productTypes(), "list", filters],
+    productType: (id) => [...productsQueryKeys.productTypes(), "detail", id],
+};

package/dist/schemas.d.ts

@@ -0,0 +1,195 @@
+import { z } from "zod";
+export declare const paginatedEnvelope: <T extends z.ZodTypeAny>(item: T) => z.ZodObject<{
+    data: z.ZodArray<T>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export declare const singleEnvelope: <T extends z.ZodTypeAny>(item: T) => z.ZodObject<{
+    data: T;
+}, z.core.$strip>;
+export declare const successEnvelope: z.ZodObject<{
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const productRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        active: "active";
+        archived: "archived";
+    }>;
+    description: z.ZodNullable<z.ZodString>;
+    bookingMode: z.ZodEnum<{
+        date: "date";
+        date_time: "date_time";
+        open: "open";
+        stay: "stay";
+        transfer: "transfer";
+        itinerary: "itinerary";
+        other: "other";
+    }>;
+    capacityMode: z.ZodEnum<{
+        free_sale: "free_sale";
+        limited: "limited";
+        on_request: "on_request";
+    }>;
+    timezone: z.ZodNullable<z.ZodString>;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        hidden: "hidden";
+    }>;
+    activated: z.ZodBoolean;
+    reservationTimeoutMinutes: z.ZodNullable<z.ZodNumber>;
+    sellCurrency: z.ZodString;
+    sellAmountCents: z.ZodNullable<z.ZodNumber>;
+    costAmountCents: z.ZodNullable<z.ZodNumber>;
+    marginPercent: z.ZodNullable<z.ZodNumber>;
+    facilityId: z.ZodNullable<z.ZodString>;
+    startDate: z.ZodNullable<z.ZodString>;
+    endDate: z.ZodNullable<z.ZodString>;
+    pax: z.ZodNullable<z.ZodNumber>;
+    productTypeId: z.ZodNullable<z.ZodString>;
+    tags: z.ZodArray<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type ProductRecord = z.infer<typeof productRecordSchema>;
+export declare const productTypeRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    code: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    sortOrder: z.ZodNumber;
+    active: z.ZodBoolean;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type ProductTypeRecord = z.infer<typeof productTypeRecordSchema>;
+export declare const productListResponse: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            draft: "draft";
+            active: "active";
+            archived: "archived";
+        }>;
+        description: z.ZodNullable<z.ZodString>;
+        bookingMode: z.ZodEnum<{
+            date: "date";
+            date_time: "date_time";
+            open: "open";
+            stay: "stay";
+            transfer: "transfer";
+            itinerary: "itinerary";
+            other: "other";
+        }>;
+        capacityMode: z.ZodEnum<{
+            free_sale: "free_sale";
+            limited: "limited";
+            on_request: "on_request";
+        }>;
+        timezone: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
+            hidden: "hidden";
+        }>;
+        activated: z.ZodBoolean;
+        reservationTimeoutMinutes: z.ZodNullable<z.ZodNumber>;
+        sellCurrency: z.ZodString;
+        sellAmountCents: z.ZodNullable<z.ZodNumber>;
+        costAmountCents: z.ZodNullable<z.ZodNumber>;
+        marginPercent: z.ZodNullable<z.ZodNumber>;
+        facilityId: z.ZodNullable<z.ZodString>;
+        startDate: z.ZodNullable<z.ZodString>;
+        endDate: z.ZodNullable<z.ZodString>;
+        pax: z.ZodNullable<z.ZodNumber>;
+        productTypeId: z.ZodNullable<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export declare const productSingleResponse: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            draft: "draft";
+            active: "active";
+            archived: "archived";
+        }>;
+        description: z.ZodNullable<z.ZodString>;
+        bookingMode: z.ZodEnum<{
+            date: "date";
+            date_time: "date_time";
+            open: "open";
+            stay: "stay";
+            transfer: "transfer";
+            itinerary: "itinerary";
+            other: "other";
+        }>;
+        capacityMode: z.ZodEnum<{
+            free_sale: "free_sale";
+            limited: "limited";
+            on_request: "on_request";
+        }>;
+        timezone: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
+            hidden: "hidden";
+        }>;
+        activated: z.ZodBoolean;
+        reservationTimeoutMinutes: z.ZodNullable<z.ZodNumber>;
+        sellCurrency: z.ZodString;
+        sellAmountCents: z.ZodNullable<z.ZodNumber>;
+        costAmountCents: z.ZodNullable<z.ZodNumber>;
+        marginPercent: z.ZodNullable<z.ZodNumber>;
+        facilityId: z.ZodNullable<z.ZodString>;
+        startDate: z.ZodNullable<z.ZodString>;
+        endDate: z.ZodNullable<z.ZodString>;
+        pax: z.ZodNullable<z.ZodNumber>;
+        productTypeId: z.ZodNullable<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const productTypeListResponse: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        code: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        sortOrder: z.ZodNumber;
+        active: z.ZodBoolean;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export declare const productTypeSingleResponse: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        code: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        sortOrder: z.ZodNumber;
+        active: z.ZodBoolean;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC;;;;;iBAM7D,CAAA;AAEJ,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC;;iBAA6B,CAAA;AAE3F,eAAO,MAAM,eAAe;;iBAAqC,CAAA;AAEjE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuB9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,uBAAuB;;;;;;;;;;iBAUlC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyC,CAAA;AACzE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsC,CAAA;AACxE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;iBAA6C,CAAA;AACjF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBAA0C,CAAA"}

package/dist/schemas.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+export const paginatedEnvelope = (item) => z.object({
+    data: z.array(item),
+    total: z.number().int(),
+    limit: z.number().int(),
+    offset: z.number().int(),
+});
+export const singleEnvelope = (item) => z.object({ data: item });
+export const successEnvelope = z.object({ success: z.boolean() });
+export const productRecordSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    status: z.enum(["draft", "active", "archived"]),
+    description: z.string().nullable(),
+    bookingMode: z.enum(["date", "date_time", "open", "stay", "transfer", "itinerary", "other"]),
+    capacityMode: z.enum(["free_sale", "limited", "on_request"]),
+    timezone: z.string().nullable(),
+    visibility: z.enum(["public", "private", "hidden"]),
+    activated: z.boolean(),
+    reservationTimeoutMinutes: z.number().int().nullable(),
+    sellCurrency: z.string(),
+    sellAmountCents: z.number().int().nullable(),
+    costAmountCents: z.number().int().nullable(),
+    marginPercent: z.number().int().nullable(),
+    facilityId: z.string().nullable(),
+    startDate: z.string().nullable(),
+    endDate: z.string().nullable(),
+    pax: z.number().int().nullable(),
+    productTypeId: z.string().nullable(),
+    tags: z.array(z.string()),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const productTypeRecordSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    code: z.string(),
+    description: z.string().nullable(),
+    sortOrder: z.number().int(),
+    active: z.boolean(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const productListResponse = paginatedEnvelope(productRecordSchema);
+export const productSingleResponse = singleEnvelope(productRecordSchema);
+export const productTypeListResponse = paginatedEnvelope(productTypeRecordSchema);
+export const productTypeSingleResponse = singleEnvelope(productTypeRecordSchema);

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@voyantjs/products-react",
+  "version": "0.1.1",
+  "license": "FSL-1.1-Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/voyantjs/voyant.git",
+    "directory": "packages/products-react"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./provider": "./src/provider.tsx",
+    "./hooks": "./src/hooks/index.ts",
+    "./client": "./src/client.ts",
+    "./query-keys": "./src/query-keys.ts"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "prepack": "pnpm run build",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run --passWithNoTests"
+  },
+  "peerDependencies": {
+    "@voyantjs/products": "workspace:*",
+    "@tanstack/react-query": "^5.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@voyantjs/products": "workspace:*",
+    "@voyantjs/voyant-typescript-config": "workspace:*",
+    "@tanstack/react-query": "^5.96.2",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2",
+    "zod": "^4.3.6"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      },
+      "./provider": {
+        "types": "./dist/provider.d.ts",
+        "import": "./dist/provider.js"
+      },
+      "./hooks": {
+        "types": "./dist/hooks/index.d.ts",
+        "import": "./dist/hooks/index.js"
+      },
+      "./client": {
+        "types": "./dist/client.d.ts",
+        "import": "./dist/client.js"
+      },
+      "./query-keys": {
+        "types": "./dist/query-keys.d.ts",
+        "import": "./dist/query-keys.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  }
+}