@reactionary/hcl 0.9.2

package/factories/category/category.factory.js

@@ -0,0 +1,60 @@
+import {} from "@reactionary/core";
+class HclCategoryFactory {
+  categorySchema;
+  categoryPaginatedResultSchema;
+  constructor(categorySchema, categoryPaginatedResultSchema) {
+    this.categorySchema = categorySchema;
+    this.categoryPaginatedResultSchema = categoryPaginatedResultSchema;
+  }
+  parseCategory(_context, data) {
+    const identifier = { key: data.identifier };
+    const slug = data.seo?.href?.split("/").filter(Boolean).pop() ?? data.identifier ?? "";
+    const pathSegments = (typeof data.parentCatalogGroupID === "string" ? data.parentCatalogGroupID : data.parentCatalogGroupID?.[0] ?? "").split("/").filter(Boolean);
+    const parentUniqueId = pathSegments.length > 1 ? pathSegments[pathSegments.length - 2] : void 0;
+    const images = [
+      data.fullImage && {
+        sourceUrl: data.fullImage,
+        altText: data.name,
+        width: 0,
+        height: 0
+      },
+      data.thumbnail && data.thumbnail !== data.fullImage && {
+        sourceUrl: data.thumbnail,
+        altText: data.name,
+        width: 0,
+        height: 0
+      }
+    ].filter(Boolean);
+    const result = {
+      identifier,
+      name: data.name ?? "",
+      slug,
+      text: data.shortDescription ?? data.description ?? "",
+      images
+    };
+    return this.categorySchema.parse({
+      ...result,
+      uniqueId: data.uniqueID,
+      parentUniqueId
+    });
+  }
+  parseCategoryPaginatedResult(context, data, query) {
+    const { pageNumber, pageSize } = query.paginationOptions;
+    const totalCount = data.length;
+    const totalPages = Math.ceil(totalCount / pageSize);
+    const offset = (pageNumber - 1) * pageSize;
+    const pageItems = data.slice(offset, offset + pageSize);
+    const items = pageItems.map((c) => this.parseCategory(context, c));
+    const result = {
+      pageNumber,
+      pageSize,
+      totalCount,
+      totalPages,
+      items
+    };
+    return this.categoryPaginatedResultSchema.parse(result);
+  }
+}
+export {
+  HclCategoryFactory
+};

package/factories/index.js

@@ -0,0 +1,3 @@
+export * from "./product/product.factory.js";
+export * from "./category/category.factory.js";
+export * from "./product-search/product-search.factory.js";

package/factories/product/product.factory.js

@@ -0,0 +1,154 @@
+import {
+  CategoryIdentifierSchema,
+  ImageSchema,
+  ProductAttributeIdentifierSchema,
+  ProductAttributeSchema,
+  ProductAttributeValueIdentifierSchema,
+  ProductAttributeValueSchema,
+  ProductOptionSchema,
+  ProductOptionValueSchema,
+  ProductVariantOptionSchema
+} from "@reactionary/core";
+const USAGE_DEFINING = "Defining";
+const USAGE_DESCRIPTIVE = "Descriptive";
+function flattenAttributeValues(attr) {
+  return attr.values.flatMap((v) => {
+    if (!Array.isArray(v.id)) {
+      const value = Array.isArray(v.value) ? v.value[0] ?? "" : v.value ?? "";
+      const key = Array.isArray(v.identifier) ? v.identifier[0] ?? "" : v.identifier ?? "";
+      return [{ key: String(key), value: String(value), label: String(value) }];
+    } else {
+      return v.id.map((_id, index) => {
+        const key = Array.isArray(v.identifier) ? String(v.identifier[index] ?? "") : String(v.identifier ?? "");
+        const value = Array.isArray(v.value) ? String(v.value[index] ?? "") : String(v.value ?? "");
+        return { key, value, label: value };
+      });
+    }
+  });
+}
+function parseSharedAttributes(data) {
+  return (data.attributes ?? []).filter(
+    (attr) => attr.usage === USAGE_DESCRIPTIVE && attr.displayable === "true" && attr.storeDisplay !== "true"
+  ).map((attr) => {
+    const flatValues = flattenAttributeValues(attr);
+    return ProductAttributeSchema.parse({
+      identifier: ProductAttributeIdentifierSchema.parse({
+        key: attr.identifier
+      }),
+      group: "",
+      name: attr.name,
+      values: flatValues.map(
+        (fv) => ProductAttributeValueSchema.parse({
+          identifier: ProductAttributeValueIdentifierSchema.parse({
+            key: fv.key
+          }),
+          value: fv.value,
+          label: fv.label
+        })
+      )
+    });
+  });
+}
+function parseOptions(skus) {
+  const optionMap = /* @__PURE__ */ new Map();
+  for (const sku of skus) {
+    for (const attr of (sku.attributes ?? []).filter(
+      (a) => a.usage === USAGE_DEFINING
+    )) {
+      if (!optionMap.has(attr.identifier)) {
+        optionMap.set(attr.identifier, { name: attr.name, values: /* @__PURE__ */ new Map() });
+      }
+      const option = optionMap.get(attr.identifier);
+      if (!option)
+        continue;
+      for (const fv of flattenAttributeValues(attr)) {
+        option.values.set(fv.key, { key: fv.key, label: fv.label });
+      }
+    }
+  }
+  return Array.from(optionMap.entries()).map(([attrId, { name, values }]) => {
+    const optionIdentifier = { key: attrId };
+    return ProductOptionSchema.parse({
+      identifier: optionIdentifier,
+      name,
+      values: Array.from(values.values()).map(
+        (v) => ProductOptionValueSchema.parse({
+          identifier: { key: v.key, option: optionIdentifier },
+          label: v.label
+        })
+      )
+    });
+  });
+}
+function parseVariant(data, productName) {
+  const images = [];
+  if (data.fullImage) {
+    images.push(
+      ImageSchema.parse({ sourceUrl: data.fullImage, altText: productName })
+    );
+  }
+  if (data.thumbnail && data.thumbnail !== data.fullImage) {
+    images.push(
+      ImageSchema.parse({ sourceUrl: data.thumbnail, altText: productName })
+    );
+  }
+  const options = (data.attributes ?? []).filter((attr) => attr.usage === USAGE_DEFINING).flatMap((attr) => {
+    const optionIdentifier = { key: attr.identifier };
+    return flattenAttributeValues(attr).map(
+      (fv) => ProductVariantOptionSchema.parse({
+        identifier: optionIdentifier,
+        name: attr.name,
+        value: {
+          identifier: { key: fv.key, option: optionIdentifier },
+          label: fv.label
+        }
+      })
+    );
+  });
+  return {
+    identifier: { sku: data.partNumber },
+    name: data.name || productName,
+    images,
+    ean: "",
+    gtin: "",
+    upc: "",
+    barcode: "",
+    options
+  };
+}
+class HclProductFactory {
+  productSchema;
+  constructor(productSchema) {
+    this.productSchema = productSchema;
+  }
+  parseProduct(_context, data) {
+    const name = data.name;
+    const slug = data.seo?.href?.split("/").filter(Boolean).pop() ?? data.seo?.tokenValue ?? data.partNumber;
+    const rawIds = Array.isArray(data.parentCatalogGroupID) ? data.parentCatalogGroupID : data.parentCatalogGroupID ? [data.parentCatalogGroupID] : [];
+    const parentCategories = rawIds.map((p) => p.split("/").filter(Boolean).at(-1) ?? p).filter(Boolean).map((id) => CategoryIdentifierSchema.parse({ key: id }));
+    const sharedAttributes = parseSharedAttributes(data);
+    const skus = !data.hasSingleSKU && data.items?.length > 0 ? data.items : [data];
+    const options = parseOptions(skus);
+    const mainVariant = parseVariant(skus[0], name);
+    const variants = skus.slice(1).map((sku) => parseVariant(sku, name));
+    const result = {
+      identifier: { key: data.partNumber },
+      name,
+      slug,
+      description: data.shortDescription ?? "",
+      longDescription: data.longDescription ?? "",
+      brand: data.manufacturer ?? "",
+      manufacturer: data.manufacturer ?? "",
+      published: data.buyable === "true",
+      parentCategories,
+      sharedAttributes,
+      options,
+      mainVariant,
+      variants
+    };
+    return this.productSchema.parse(result);
+  }
+}
+export {
+  HclProductFactory
+};

package/factories/product-search/product-search.factory.js

@@ -0,0 +1,71 @@
+class HclProductSearchFactory {
+  productSearchResultSchema;
+  constructor(productSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+  parseSearchResult(_context, data, query) {
+    const rawItems = data.contents ?? data.catalogEntryView ?? [];
+    const { pageNumber, pageSize } = query.search.paginationOptions;
+    const totalCount = data.total ?? data.recordSetTotal ?? rawItems.length;
+    const items = rawItems.map(
+      (p) => this.parseSearchItem(p)
+    );
+    const facets = (data.facets ?? []).map(
+      (f) => this.parseFacet(f, query)
+    );
+    const result = {
+      identifier: query.search,
+      pageNumber,
+      pageSize,
+      totalCount,
+      totalPages: Math.ceil(totalCount / pageSize),
+      items,
+      facets
+    };
+    return this.productSearchResultSchema.parse(result);
+  }
+  parseSearchItem(p) {
+    const slug = p.seo?.href?.split("/").filter(Boolean).pop() ?? p.seo?.tokenValue ?? p.partNumber;
+    const variants = [
+      {
+        variant: { sku: p.partNumber },
+        image: {
+          sourceUrl: p.fullImage || p.thumbnail || "",
+          altText: p.name,
+          width: 0,
+          height: 0
+        }
+      }
+    ];
+    return {
+      identifier: { key: p.partNumber },
+      name: p.name ?? "",
+      slug,
+      variants
+    };
+  }
+  parseFacet(f, query) {
+    const facetId = { key: f.value };
+    const values = (f.entry ?? []).map(
+      (entry) => {
+        const isActive = query.search.facets.some(
+          (sel) => sel.facet.key === f.value && sel.key === entry.value
+        );
+        return {
+          identifier: { facet: facetId, key: entry.value },
+          name: entry.label || entry.name || entry.value,
+          count: Number(entry.count) || 0,
+          active: isActive
+        };
+      }
+    );
+    return {
+      identifier: facetId,
+      name: f.name || f.value,
+      values
+    };
+  }
+}
+export {
+  HclProductSearchFactory
+};

package/index.js

@@ -0,0 +1,11 @@
+export * from "./schema/configuration.schema.js";
+export * from "./schema/capabilities.schema.js";
+export * from "./schema/hcl.schema.js";
+export * from "./schema/category.schema.js";
+export * from "./core/client.js";
+export * from "./core/initialize.js";
+export * from "./core/initialize.types.js";
+export * from "./factories/index.js";
+export * from "./capabilities/product.capability.js";
+export * from "./capabilities/category.capability.js";
+export * from "./capabilities/product-search.capability.js";

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@reactionary/hcl",
+  "version": "0.9.2",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "@reactionary/core": "0.9.2",
+    "zod": "4.1.9",
+    "vitest": "^4.0.9",
+    "@nx/vite": "22.4.5"
+  },
+  "sideEffects": false
+}

package/schema/capabilities.schema.js

@@ -0,0 +1,27 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional()
+});
+const HclCapabilitiesSchema = CapabilitiesSchema.pick({
+  cart: true,
+  checkout: true,
+  category: true,
+  product: true,
+  price: true,
+  inventory: true,
+  productSearch: true
+}).extend({
+  cart: OverridableCapabilitySchema.optional(),
+  checkout: OverridableCapabilitySchema.optional(),
+  category: OverridableCapabilitySchema.optional(),
+  product: OverridableCapabilitySchema.optional(),
+  price: OverridableCapabilitySchema.optional(),
+  inventory: OverridableCapabilitySchema.optional(),
+  productSearch: OverridableCapabilitySchema.optional()
+}).partial();
+export {
+  HclCapabilitiesSchema
+};

package/schema/category.schema.js

@@ -0,0 +1,9 @@
+import { CategorySchema } from "@reactionary/core";
+import * as z from "zod";
+const HclCategorySchema = CategorySchema.extend({
+  uniqueId: z.string().optional(),
+  parentUniqueId: z.string().optional()
+});
+export {
+  HclCategorySchema
+};

package/schema/configuration.schema.js

@@ -0,0 +1,33 @@
+import * as z from "zod";
+const HclProfilesSchema = z.looseObject({
+  product: z.string().default("HCL_V2_findProductByPartNumber_Details").meta({
+    description: "Profile name for product detail lookups (getById, getBySlug, getBySKU)."
+  }),
+  productSearch: z.string().default("HCL_V2_findProductsBySearchTermWithPrice").meta({ description: "Profile name for product search by term." }),
+  categoryBrowse: z.string().default("HCL_V2_findProductsByCategoryWithPriceRange").meta({
+    description: "Profile name for product search filtered by category."
+  })
+}).default(() => ({
+  product: "HCL_V2_findProductByPartNumber_Details",
+  productSearch: "HCL_V2_findProductsBySearchTermWithPrice",
+  categoryBrowse: "HCL_V2_findProductsByCategoryWithPriceRange"
+}));
+const HclConfigurationSchema = z.looseObject({
+  apiUrl: z.string().meta({
+    description: "The base origin URL for the HCL Commerce server (e.g. https://example.com)."
+  }),
+  storeId: z.string().meta({ description: "The HCL Commerce store identifier." }),
+  catalogId: z.string().optional().meta({ description: "The HCL Commerce catalog identifier." }),
+  /**
+   * Maps BCP 47 locale strings (from RequestContext) to HCL Commerce langId values.
+   * HCL uses numeric language identifiers (e.g. -1 for English, -11 for Finnish).
+   * Add an entry for each locale your store supports.
+   */
+  localeMap: z.record(z.string(), z.string()).default({ "en-US": "-1" }).meta({
+    description: "Mapping from BCP 47 locale (RequestContext.languageContext.locale) to HCL langId."
+  }),
+  profiles: HclProfilesSchema
+});
+export {
+  HclConfigurationSchema
+};

package/src/capabilities/category.capability.d.ts

@@ -0,0 +1,15 @@
+import { CategoryCapability, type Cache, type CategoryFactory, type CategoryFactoryCategoryOutput, type CategoryFactoryPaginatedOutput, type CategoryFactoryWithOutput, type CategoryQueryById, type CategoryQueryBySlug, type CategoryQueryForBreadcrumb, type CategoryQueryForChildCategories, type CategoryQueryForTopCategories, type NotFoundError, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclCategoryFactory } from '../factories/category/category.factory.js';
+export declare class HclCategoryCapability<TFactory extends CategoryFactory = HclCategoryFactory> extends CategoryCapability<CategoryFactoryCategoryOutput<TFactory>, CategoryFactoryPaginatedOutput<TFactory>> {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: CategoryFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: CategoryFactoryWithOutput<TFactory>);
+    getById(payload: CategoryQueryById): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
+    getBySlug(payload: CategoryQueryBySlug): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
+    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Array<CategoryFactoryCategoryOutput<TFactory>>>>;
+    findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>>;
+    findTopCategories(payload: CategoryQueryForTopCategories): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>>;
+}

package/src/capabilities/product-search.capability.d.ts

@@ -0,0 +1,14 @@
+import { ProductSearchCapability, type Cache, type FacetValueIdentifier, type ProductSearchFactory, type ProductSearchFactoryOutput, type ProductSearchFactoryWithOutput, type ProductSearchQueryByTerm, type ProductSearchQueryCreateNavigationFilter, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { HclFindProductsQuery } from '../schema/hcl.schema.js';
+export declare class HclProductSearchCapability<TFactory extends ProductSearchFactory = HclProductSearchFactory> extends ProductSearchCapability<ProductSearchFactoryOutput<TFactory>> {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: ProductSearchFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: ProductSearchFactoryWithOutput<TFactory>);
+    protected queryByTermPayload(payload: ProductSearchQueryByTerm): HclFindProductsQuery;
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchFactoryOutput<TFactory>>>;
+    createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
+}

package/src/capabilities/product.capability.d.ts

@@ -0,0 +1,20 @@
+import { ProductCapability, type Cache, type NotFoundError, type ProductFactory, type ProductFactoryOutput, type ProductFactoryWithOutput, type ProductQueryById, type ProductQueryBySKU, type ProductQueryBySlug, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclProductFactory } from '../factories/product/product.factory.js';
+import type { HclProductResponse } from '../schema/hcl.schema.js';
+export declare class HclProductCapability<TFactory extends ProductFactory = HclProductFactory> extends ProductCapability<ProductFactoryOutput<TFactory>> {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: ProductFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: ProductFactoryWithOutput<TFactory>);
+    getById(payload: ProductQueryById): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>>;
+    getBySlug(payload: ProductQueryBySlug): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>>;
+    getBySKU(payload: ProductQueryBySKU): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>>;
+    /**
+     * Resolves `parentCatalogGroupID` path strings (e.g. "/10505/10507") to external
+     * category identifiers (e.g. "LivingRoomFurniture") so the factory receives
+     * human-readable keys rather than internal uniqueIDs.
+     */
+    protected withResolvedParentCategories(data: HclProductResponse, langId: string): Promise<HclProductResponse>;
+}

package/src/core/client.d.ts

@@ -0,0 +1,19 @@
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclCategoryQueryResponse, HclFindCategoriesQuery, HclFindProductsQuery, HclProductQueryResponse, HclUrlResponse } from '../schema/hcl.schema.js';
+export declare class HclClient {
+    private readonly config;
+    private readonly baseUrl;
+    constructor(config: HclConfiguration);
+    findProducts(query: HclFindProductsQuery): Promise<HclProductQueryResponse>;
+    /**
+     * Resolve a URL slug to an HCL token (product partNumber, category ID, etc.).
+     * Calls GET /api/v2/urls?storeId=X&identifier=<slug>
+     * Returns undefined when the slug is not found (404).
+     */
+    resolveSlug(slug: string, langId?: string): Promise<HclUrlResponse | undefined>;
+    /**
+     * Query categories from the HCL Commerce Query Service.
+     * Calls GET /api/v2/categories with the given query parameters.
+     */
+    findCategories(query: HclFindCategoriesQuery): Promise<HclCategoryQueryResponse>;
+}

package/src/core/initialize.d.ts

@@ -0,0 +1,5 @@
+import type { Cache, RequestContext } from '@reactionary/core';
+import { type HclCapabilities } from '../schema/capabilities.schema.js';
+import { type HclConfiguration } from '../schema/configuration.schema.js';
+import { type HclClientFromCapabilities } from './initialize.types.js';
+export declare function withHclCapabilities<T extends HclCapabilities>(configuration: HclConfiguration, capabilities: T): (cache: Cache, context: RequestContext) => HclClientFromCapabilities<T>;

package/src/core/initialize.types.d.ts

@@ -0,0 +1,42 @@
+import type { ClientFromCapabilities } from '@reactionary/core';
+import type { HclCapabilities } from '../schema/capabilities.schema.js';
+import type { HclProductCapability } from '../capabilities/product.capability.js';
+import type { HclCategoryCapability } from '../capabilities/category.capability.js';
+import type { HclProductSearchCapability } from '../capabilities/product-search.capability.js';
+type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'price' | 'inventory';
+type EnabledCapability<TCapability> = TCapability extends {
+    enabled: true;
+} ? true : false;
+type NormalizeConfiguredCapabilities<T extends HclCapabilities> = {
+    [K in OverridableCapabilityKey]?: EnabledCapability<T[K]>;
+};
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> = TCapability extends {
+    enabled: true;
+    capability?: infer TCapabilityFactory;
+} ? TCapabilityFactory extends (...args: unknown[]) => infer TResolvedCapability ? TResolvedCapability : TDefaultCapability : TDefaultCapability;
+type DefaultCapabilityMap = {
+    product: HclProductCapability;
+    productSearch: HclProductSearchCapability;
+    cart: never;
+    checkout: never;
+    category: HclCategoryCapability;
+    price: never;
+    inventory: never;
+};
+type CapabilityImplementationMap<T extends HclCapabilities> = {
+    [K in OverridableCapabilityKey]: ExtractCapabilityImplementation<T[K], DefaultCapabilityMap[K]>;
+};
+type EnabledCapabilityOverrideMap<T extends HclCapabilities> = {
+    [K in OverridableCapabilityKey as T[K] extends {
+        enabled: true;
+    } ? K : never]: CapabilityImplementationMap<T>[K];
+};
+export type HclClientFromCapabilities<T extends HclCapabilities> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, OverridableCapabilityKey> & EnabledCapabilityOverrideMap<T>;
+export declare function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TCapabilityArgs>(capability: {
+    factory?: TFactory;
+    capability?: (args: TCapabilityArgs) => TResolvedCapability;
+} | undefined, defaults: {
+    factory: TFactory;
+    capability: (args: TCapabilityArgs) => TResolvedCapability;
+}, buildCapabilityArgs: (factory: TFactory) => TCapabilityArgs): TResolvedCapability;
+export {};

package/src/core/locale-params.d.ts

@@ -0,0 +1,6 @@
+import type { RequestContext } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+export declare function getLocaleParams(config: HclConfiguration, context: RequestContext): {
+    langId: string;
+    currency: string;
+};

package/src/factories/category/category.factory.d.ts

@@ -0,0 +1,12 @@
+import type { AnyCategoryPaginatedResultSchema, AnyCategorySchema, CategoryFactory, RequestContext, CategoryQueryForTopCategories, CategoryQueryForChildCategories } from '@reactionary/core';
+import type * as z from 'zod';
+import type { HclCategoryResponse } from '../../schema/hcl.schema.js';
+import { type CategoryPaginatedResultSchema } from '@reactionary/core';
+import type { HclCategorySchema } from '../../schema/category.schema.js';
+export declare class HclCategoryFactory<TCategorySchema extends AnyCategorySchema = typeof HclCategorySchema, TCategoryPaginatedSchema extends AnyCategoryPaginatedResultSchema = typeof CategoryPaginatedResultSchema> implements CategoryFactory<TCategorySchema, TCategoryPaginatedSchema> {
+    readonly categorySchema: TCategorySchema;
+    readonly categoryPaginatedResultSchema: TCategoryPaginatedSchema;
+    constructor(categorySchema: TCategorySchema, categoryPaginatedResultSchema: TCategoryPaginatedSchema);
+    parseCategory(_context: RequestContext, data: HclCategoryResponse): z.output<TCategorySchema>;
+    parseCategoryPaginatedResult(context: RequestContext, data: HclCategoryResponse[], query: CategoryQueryForTopCategories | CategoryQueryForChildCategories): z.output<TCategoryPaginatedSchema>;
+}

package/src/factories/index.d.ts

@@ -0,0 +1,3 @@
+export * from './product/product.factory.js';
+export * from './category/category.factory.js';
+export * from './product-search/product-search.factory.js';

package/src/factories/product/product.factory.d.ts

@@ -0,0 +1,8 @@
+import { type ProductSchema, type AnyProductSchema, type ProductFactory, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { HclProductResponse } from '../../schema/hcl.schema.js';
+export declare class HclProductFactory<TProductSchema extends AnyProductSchema = typeof ProductSchema> implements ProductFactory<TProductSchema> {
+    readonly productSchema: TProductSchema;
+    constructor(productSchema: TProductSchema);
+    parseProduct(_context: RequestContext, data: HclProductResponse): z.output<TProductSchema>;
+}

package/src/factories/product-search/product-search.factory.d.ts

@@ -0,0 +1,11 @@
+import type { AnyProductSearchResultSchema, ProductSearchFactory, ProductSearchResultFacet, ProductSearchResultItem, RequestContext, ProductSearchQueryByTerm } from '@reactionary/core';
+import type * as z from 'zod';
+import type { ProductSearchResultSchema } from '@reactionary/core';
+import type { HclFacet, HclProductQueryResponse, HclProductSearchItem } from '../../schema/hcl.schema.js';
+export declare class HclProductSearchFactory<TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema> implements ProductSearchFactory<TProductSearchResultSchema> {
+    readonly productSearchResultSchema: TProductSearchResultSchema;
+    constructor(productSearchResultSchema: TProductSearchResultSchema);
+    parseSearchResult(_context: RequestContext, data: HclProductQueryResponse, query: ProductSearchQueryByTerm): z.output<TProductSearchResultSchema>;
+    protected parseSearchItem(p: HclProductSearchItem): ProductSearchResultItem;
+    protected parseFacet(f: HclFacet, query: ProductSearchQueryByTerm): ProductSearchResultFacet;
+}

package/src/index.d.ts

@@ -0,0 +1,11 @@
+export * from './schema/configuration.schema.js';
+export * from './schema/capabilities.schema.js';
+export * from './schema/hcl.schema.js';
+export * from './schema/category.schema.js';
+export * from './core/client.js';
+export * from './core/initialize.js';
+export * from './core/initialize.types.js';
+export * from './factories/index.js';
+export * from './capabilities/product.capability.js';
+export * from './capabilities/category.capability.js';
+export * from './capabilities/product-search.capability.js';

package/src/schema/capabilities.schema.d.ts

@@ -0,0 +1,63 @@
+import type { Cache, RequestContext, CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability } from '@reactionary/core';
+import type { HclConfiguration } from './configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import * as z from 'zod';
+export declare const HclCapabilitiesSchema: z.ZodObject<{
+    cart: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    checkout: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    category: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    product: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    price: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    inventory: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    productSearch: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type HclCapabilities = z.infer<typeof HclCapabilitiesSchema>;
+export interface HclCapabilityFactoryArgs {
+    cache: Cache;
+    context: RequestContext;
+    config: HclConfiguration;
+    hclClient: HclClient;
+}
+export interface HclFactoryCapabilityArgs<TFactory> extends HclCapabilityFactoryArgs {
+    factory: TFactory;
+}
+export interface HclCapabilityConfig<TFactory, TCapability> {
+    enabled: boolean;
+    factory?: TFactory;
+    capability?: (args: HclFactoryCapabilityArgs<TFactory>) => TCapability;
+}
+export type HclCartCapabilityConfig = HclCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartCapability>;
+export type HclCategoryCapabilityConfig = HclCapabilityConfig<CategoryFactoryWithOutput<CategoryFactory>, CategoryCapability>;
+export type HclCheckoutCapabilityConfig = HclCapabilityConfig<CheckoutFactoryWithOutput<CheckoutFactory>, CheckoutCapability>;
+export type HclInventoryCapabilityConfig = HclCapabilityConfig<InventoryFactoryWithOutput<InventoryFactory>, InventoryCapability>;
+export type HclPriceCapabilityConfig = HclCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceCapability>;
+export type HclProductCapabilityConfig = HclCapabilityConfig<ProductFactoryWithOutput<ProductFactory>, ProductCapability>;
+export type HclProductSearchCapabilityConfig = HclCapabilityConfig<ProductSearchFactoryWithOutput<ProductSearchFactory>, ProductSearchCapability>;