Class SupplierLaballey

SupplierLaballey class that extends SupplierBaseShopify and implements AsyncIterable.

Hierarchy (View Summary)

SupplierBaseShopify
- SupplierLaballey

Implements

ISupplier

Constructors

constructor

new SupplierLaballey(
    query: string,
    limit?: number,
    controller?: AbortController,
): SupplierLaballey
Creates a new instance of the supplier base class. Initializes the supplier with query parameters, request limits, and abort controller. Sets up logging and default product values.
Parameters
- query: string
  The search term to query products for
- limit: number = 5
  The maximum number of results to return (default: 5)
- Optionalcontroller: AbortController
  AbortController instance for managing request cancellation
Returns SupplierLaballey
Example
```
// Create a supplier with default limit
const supplier = new MySupplier("sodium chloride", undefined, new AbortController());

// Create a supplier with custom limit
const supplier = new MySupplier("acetone", 10, new AbortController());

// Create a supplier and handle cancellation
const controller = new AbortController();
const supplier = new MySupplier("ethanol", 5, controller);

// Later, to cancel all pending requests:
controller.abort();
```
Inherited from SupplierBaseShopify.constructor
- Defined in src/suppliers/SupplierBase.ts:313

Methods

initCache

initCache(): void
Initializes the cache for the supplier. This is called after construction to ensure supplierName is set.

Returns void
Remarks
The cache is initialized with the supplier's name and is used to store both query results and product data. This method should be called after the supplier's name is set to ensure proper cache key generation.
Example
```
class MySupplier extends SupplierBase<Product> {
  constructor() {
    super("acetone", 5);
    // supplierName is set here
    this.initCache(); // Initialize cache after supplierName is set
  }
}
```
Inherited from SupplierBaseShopify.initCache
- Defined in src/suppliers/SupplierBase.ts:341

`Protected`setup

setup(): Promise<void>
Placeholder for any setup that needs to be done before the query is made. Override this in subclasses if you need to perform setup (e.g., authentication, token fetching).

Returns Promise<void>
A promise that resolves when the setup is complete.
Example
```
await supplier.setup();
```
Inherited from SupplierBaseShopify.setup
- Defined in src/suppliers/SupplierBase.ts:356

`Protected`httpGetHeaders

httpGetHeaders(url: string | URL): Promise<Maybe<HeadersInit>>
Retrieves HTTP headers from a URL using a HEAD request. Useful for checking content types, caching headers, and other metadata without downloading the full response.
Parameters
- url: string | URL
  The URL to fetch headers from
Returns Promise<Maybe<HeadersInit>>
Promise resolving to the response headers or void if request fails
Example
```
// Basic usage
const headers = await supplier.httpGetHeaders('https://example.com/product/123');
if (headers) {
  console.log('Content-Type:', headers['content-type']);
}
```
Example
```
// With error handling
try {
  const headers = await supplier.httpGetHeaders('https://example.com/product/123');
  if (headers) {
    console.log('Headers:', headers);
  }
} catch (err) {
  console.error('Failed to fetch headers:', err);
}
```
Inherited from SupplierBaseShopify.httpGetHeaders
- Defined in src/suppliers/SupplierBase.ts:387

`Protected`httpPost

httpPost(options: RequestOptions): Promise<Maybe<Response>>

Sends a POST request to the given URL with the given body and headers. Handles request setup, error handling, and response caching.

Parameters

options: RequestOptions
The request configuration options

Returns Promise<Maybe<Response>>

Promise resolving to the Response object or void if request fails

Example

// Basic POST request
const response = await supplier.httpPost({
  path: '/api/v1/products',
  body: { name: 'Test Chemical' }
});

Example

// POST with custom headers
const response = await supplier.httpPost({
  path: '/api/v1/products',
  body: { name: 'Test Chemical' },
  headers: {
    'Authorization': 'Bearer token123',
    'Content-Type': 'application/json'
  }
});

Example

// POST with custom host and params
const response = await supplier.httpPost({
  path: '/api/v1/products',
  host: 'api.example.com',
  body: { name: 'Test Chemical' },
  params: { version: '2' }
});

Example

// Error handling
try {
  const response = await supplier.httpPost({ path: '/api/v1/products', body: { name: 'Test' } });
  if (response && response.ok) {
    const data = await response.json();
    console.log('Created:', data);
  }
} catch (err) {
  console.error('POST failed:', err);
}

`Protected`httpPostJson

httpPostJson(params: RequestOptions): Promise<Maybe<JsonValue>>

Sends a POST request and returns the response as a JSON object.

Parameters

params: RequestOptions
The parameters for the POST request.

Returns Promise<Maybe<JsonValue>>

The response from the POST request as a JSON object.

Example

// Basic usage
const data = await supplier.httpPostJson({
  path: '/api/v1/products',
  body: { name: 'John' }
});

Example

// With custom headers and error handling
try {
  const data = await supplier.httpPostJson({
    path: '/api/v1/products',
    body: { name: 'John' },
    headers: { 'Authorization': 'Bearer token123' }
  });
  if (data) {
    console.log('Created:', data);
  }
} catch (err) {
  console.error('POST JSON failed:', err);
}

`Protected`httpPostHtml

httpPostHtml(options: RequestOptions): Promise<Maybe<string>>
Sends a POST request and returns the response as a HTML string.
Parameters
- options: RequestOptions
  The request configuration options
Returns Promise<Maybe<string>>
Promise resolving to the HTML response as a string or void if request fails
Throws
TypeError - If the response is not valid HTML content
Example
```
// Basic usage
const html = await supplier.httpPostHtml({
  path: '/api/v1/products',
  body: { name: 'John' }
});
```
Inherited from SupplierBaseShopify.httpPostHtml
- Defined in src/suppliers/SupplierBase.ts:573

`Protected`httpGet

httpGet(options: RequestOptions): Promise<Maybe<Response>>

Sends a GET request to the given URL with the specified options. Handles request setup, error handling, and response caching.

Parameters

options: RequestOptions
The request configuration options

Returns Promise<Maybe<Response>>

Promise resolving to the Response object or void if request fails

Example

// Basic GET request
const response = await supplier.httpGet({
  path: '/products/search',
  params: { query: 'sodium chloride' }
});

Example

// GET with custom headers
const response = await supplier.httpGet({
  path: '/products/search',
  headers: { 'Accept': 'application/json' }
});

Example

// GET with custom host
const response = await supplier.httpGet({
  path: '/products/search',
  host: 'api.example.com',
  params: { category: 'chemicals' }
});

Example

// Error handling
try {
  const response = await supplier.httpGet({ path: '/products/search' });
  if (response && response.ok) {
    const data = await response.json();
    console.log('Products:', data);
  }
} catch (err) {
  console.error('GET failed:', err);
}

`Protected`fuzzyFilter

fuzzyFilter<X>(query: string, data: X[], cutoff?: number): X[]

Filters an array of data using fuzzy string matching to find items that closely match a query string. Uses the WRatio algorithm from fuzzball for string similarity comparison.

Type Parameters

Parameters

query: string
The search string to match against
data: X[]
Array of data objects to search through
cutoff: number = 40
Minimum similarity score (0-100) for a match to be included (default: 40)

Returns X[]

Array of matching data objects with added fuzzy match metadata

Example

// Example with simple string array
const products = [
  { title: "Sodium Chloride", price: 29.99 },
  { title: "Sodium Hydroxide", price: 39.99 },
  { title: "Potassium Chloride", price: 19.99 }
];

const matches = this.fuzzyFilter("sodium chloride", products);
// Returns: [
//   {
//     title: "Sodium Chloride",
//     price: 29.99,
//     ___fuzz: { score: 100, idx: 0 }
//   },
//   {
//     title: "Sodium Hydroxide",
//     price: 39.99,
//     ___fuzz: { score: 85, idx: 1 }
//   }
// ]

// Example with custom cutoff
const strictMatches = this.fuzzyFilter("sodium chloride", products, 90);
// Returns only exact matches with score >= 90

// Example with different data structure
const chemicals = [
  { name: "NaCl", formula: "Sodium Chloride" },
  { name: "NaOH", formula: "Sodium Hydroxide" }
];

// Override titleSelector to use formula field
this.titleSelector = (data) => data.formula;
const formulaMatches = this.fuzzyFilter("sodium chloride", chemicals);

`Protected`httpGetHtml

httpGetHtml(options: RequestOptions): Promise<Maybe<string>>
Makes an HTTP GET request and returns the response as a string. Handles request configuration, error handling, and HTML parsing.
Parameters
- options: RequestOptions
  The request configuration options
Returns Promise<Maybe<string>>
Promise resolving to the HTML response as a string or void if request fails
Throws
TypeError - If the response is not valid HTML content
Example
```
// Basic GET request
const html = await this.httpGetHtml({
  path: "/api/products",
  params: { search: "sodium" }
});

// GET request with custom headers
const html = await this.httpGetHtml({
  path: "/api/products",
  headers: {
    "Authorization": "Bearer token123",
    "Accept": "text/html"
  }
});

// GET request with custom host
const html = await this.httpGetHtml({
  path: "/products",
  host: "api.supplier.com",
  params: { limit: 10 }
});
```
Inherited from SupplierBaseShopify.httpGetHtml
- Defined in src/suppliers/SupplierBase.ts:822

`Protected`httpGetJson

httpGetJson(options: RequestOptions): Promise<Maybe<JsonValue>>

Makes an HTTP GET request and returns the response as parsed JSON. Handles request configuration, error handling, and JSON parsing.

Parameters

options: RequestOptions
The request configuration options

Returns Promise<Maybe<JsonValue>>

Promise resolving to the parsed JSON response or void if request fails

Throws

TypeError - If the response is not valid JSON content

Example

// Basic GET request
const data = await supplier.httpGetJson({ path: '/api/products', params: { search: 'sodium' } });

Example

// GET request with custom headers
const data = await supplier.httpGetJson({
  path: '/api/products',
  headers: {
    'Authorization': 'Bearer token123',
    'Accept': 'application/json'
  }
});

Example

// GET request with custom host
const data = await supplier.httpGetJson({
  path: '/products',
  host: 'api.supplier.com',
  params: { limit: 10 }
});

Example

// Error handling
try {
  const data = await supplier.httpGetJson({ path: '/api/products' });
  if (data) {
    console.log('Products:', data);
  }
} catch (error) {
  console.error('Failed to fetch products:', error);
}

`Protected`queryProductsWithCache

queryProductsWithCache(
query: string,
limit?: number,
): Promise<void | ProductBuilder<Product>[]>
Executes a product search query with caching support. First checks the cache for existing results, then falls back to the actual query if needed. The limit parameter is only used for the actual query and doesn't affect caching.
Parameters
- query: string
  The search term to query products for
- limit: number = ...
  The maximum number of results to return (defaults to instance limit)
Returns Promise<void | ProductBuilder<Product>[]>
Promise resolving to array of product builders or void if search fails
Example
```
// Basic usage with default limit
const results = await supplier.queryProductsWithCache("acetone");
if (results) {
  console.log(`Found ${results.length} products`);
}
```
Example
```
// With custom limit
const results = await supplier.queryProductsWithCache("acetone", 10);
if (results) {
  for (const builder of results) {
    const product = await builder.build();
    console.log(product.title, product.price);
  }
}
```
Inherited from SupplierBaseShopify.queryProductsWithCache
- Defined in src/suppliers/SupplierBase.ts:931

execute

execute(): AsyncGenerator<Product, void, undefined>
Executes the supplier's search query and returns the results. This method will execute all results concurrently (to the limits set in the supplier class), and resolve to an array of product objects.

Returns AsyncGenerator<Product, void, undefined>
Promise resolving to an array of products

Remarks
This method is used to execute the supplier's search query and return the results.
Inherited from SupplierBaseShopify.execute
- Defined in src/suppliers/SupplierBase.ts:983

`Protected`finishProduct

finishProduct(product: ProductBuilder<Product>): Promise<Maybe<Product>>

Finalizes a partial product by adding computed properties and validating the result. This method:

Validates the product has minimal required properties
Computes USD price if product is in different currency
Calculates base quantity using the unit of measure
Ensures the product URL is absolute

Parameters

product: ProductBuilder<Product>
The ProductBuilder instance containing the partial product to finalize

Returns Promise<Maybe<Product>>

Promise resolving to a complete Product object or void if validation fails

Example

// Example with a valid partial product
const builder = new ProductBuilder<Product>(this.baseURL);
builder
  .setBasicInfo("Sodium Chloride", "/products/nacl", "ChemSupplier")
  .setPricing(29.99, "USD", "$")
  .setQuantity(500, "g");

const finishedProduct = await this.finishProduct(builder);
if (finishedProduct) {
  console.log("Finalized product:", {
    title: finishedProduct.title,
    price: finishedProduct.price,
    quantity: finishedProduct.quantity,
    uom: finishedProduct.uom,
    usdPrice: finishedProduct.usdPrice,
    baseQuantity: finishedProduct.baseQuantity
  });
}

// Example with an invalid partial product
const invalidBuilder = new ProductBuilder<Product>(this.baseURL);
invalidBuilder.setBasicInfo("Sodium Chloride", "/products/nacl", "ChemSupplier");
// Missing required fields

const invalidProduct = await this.finishProduct(invalidBuilder);
if (!invalidProduct) {
  console.log("Failed to finalize product - missing required fields");
}

`Protected`href

href(path: string | URL, params?: Maybe<RequestParams>, host?: string): string

Takes in either a relative or absolute URL and returns an absolute URL. This is useful for when you aren't sure if the link (retrieved from parsed text, a setting, an element, an anchor value, etc) is absolute or not. Using relative links will result in http://chrome-extension://... being added to the link.

Parameters

path: string | URL
URL object or string
Optionalparams: Maybe<RequestParams>
The parameters to add to the URL.
Optionalhost: string
The host to use for overrides (eg: needing to call a different host for an API)

Returns string

absolute URL

Example

this.href('/some/path')
// https://supplier_base_url.com/some/path

this.href('https://supplier_base_url.com/some/path', null, 'another_host.com')
// https://another_host.com/some/path

this.href('/some/path', { a: 'b', c: 'd' }, 'another_host.com')
// http://another_host.com/some/path?a=b&c=d

this.href('https://supplier_base_url.com/some/path')
// https://supplier_base_url.com/some/path

this.href(new URL('https://supplier_base_url.com/some/path'))
// https://supplier_base_url.com/some/path

this.href('/some/path', { a: 'b', c: 'd' })
// https://supplier_base_url.com/some/path?a=b&c=d

this.href('https://supplier_base_url.com/some/path', new URLSearchParams({ a: 'b', c: 'd' }))
// https://supplier_base_url.com/some/path?a=b&c=d

`Protected`getProductDataWithCache

getProductDataWithCache(
    product: ProductBuilder<Product>,
    fetcher: (
        builder: ProductBuilder<Product>,
    ) => Promise<void | ProductBuilder<Product>>,
    params?: Record<string, string>,
): Promise<void | ProductBuilder<Product>>
Retrieves product data with caching support. Similar to getProductData but allows for additional parameters to be included in the cache key.
Parameters
- product: ProductBuilder<Product>
  The ProductBuilder instance to get data for
- fetcher: (builder: ProductBuilder<Product>) => Promise<void | ProductBuilder<Product>>
  The function to use for fetching product data
- Optionalparams: Record<string, string>
  Optional parameters to include in the cache key
Returns Promise<void | ProductBuilder<Product>>
Promise resolving to the updated ProductBuilder or void if fetch fails
Example
```
const builder = new ProductBuilder<Product>(this.baseURL);
builder.setBasicInfo("Acetone", "/products/acetone", "ChemSupplier");

// Use custom fetcher with additional params
const updatedBuilder = await supplier.getProductDataWithCache(
  builder,
  async (b) => {
    // Custom fetching logic
    return b;
  },
  { version: "2.0" }
);
```
Inherited from SupplierBaseShopify.getProductDataWithCache
- Defined in src/suppliers/SupplierBase.ts:1316

`Protected`groupVariants

groupVariants<R>(data: R[]): R[]
Groups variants of a product by their title
Type Parameters
- R
Parameters
- data: R[]
  Array of product listings from search results
Returns R[]
Array of product listings with grouped variants
Todo
Create a generic method for this, the same method is used in Synthetika and could be of use with LoudWolf.
Example
```
const results = await this.queryProducts("sodium chloride");
const grouped = this.groupVariants(results);
// grouped is an array of product listings with grouped variants
```
Inherited from SupplierBaseShopify.groupVariants
- Defined in src/suppliers/SupplierBase.ts:1365

`Protected`fetch

fetch(...args: [input: URL | RequestInfo, init?: RequestInit]): Promise<any>
Internal fetch method with request counting and decorator. Tracks request count and enforces hard limits on HTTP requests.
Parameters
- ...args: [input: URL | RequestInfo, init?: RequestInit]
  Arguments to pass to fetchDecorator (usually a Request or URL and options)
Returns Promise<any>
The response from the fetchDecorator
Throws
Error if request count exceeds hard limit
Example
```
// Example usage inside a subclass:
const response = await this.fetch(new Request('https://example.com'));
if (response.ok) {
  const data = await response.json();
  console.log(data);
}
```
Example
```
// With custom request options
const response = await this.fetch(
  new Request('https://example.com', {
    headers: { 'Accept': 'application/json' }
  })
);
```
Inherited from SupplierBaseShopify.fetch
- Defined in src/suppliers/SupplierBase.ts:1423

`Protected`queryProducts

queryProducts(
query: string,
limit?: number,
): Promise<void | ProductBuilder<Product>[]>

Query products from the Shopify API

Parameters

query: string
The query to search for
limit: number = ...
The limit of products to return

Returns Promise<void | ProductBuilder<Product>[]>

A promise that resolves when the products are queried

Example

// Search for sodium chloride with a limit of 10 results
const products = await this.queryProducts("sodium chloride", 10);
if (products) {
  console.log(`Found ${products.length} products`);
  for (const product of products) {
    const builtProduct = await product.build();
    console.log({
      title: builtProduct.title,
      price: builtProduct.price,
      quantity: builtProduct.quantity,
      uom: builtProduct.uom
    });
  }
}

`Protected`initProductBuilders

initProductBuilders(results: ItemListing[]): ProductBuilder<Product>[]
Initialize product builders from Shopify search response data. Transforms Shopify product listings into ProductBuilder instances, handling:
- Basic product information (title, link, supplier)
- Pricing information in USD
- Product descriptions
- SKU/product codes
- Vendor information
- Quantity parsing from multiple fields
- Shopify-specific variants with their attributes
Parameters
- results: ItemListing[]
  Array of Shopify item listings from search results
Returns ProductBuilder<Product>[]
Array of ProductBuilder instances initialized with Shopify product data
Example
```
const results = await this.queryProducts("sodium chloride");
if (results) {
  const builders = this.initProductBuilders(results);
  // Each builder contains parsed product data from Shopify
  for (const builder of builders) {
    const product = await builder.build();
    console.log({
      title: product.title,
      price: product.price,
      quantity: product.quantity,
      uom: product.uom,
      variants: product.variants
    });
  }
}
```
Inherited from SupplierBaseShopify.initProductBuilders
- Defined in src/suppliers/SupplierBaseShopify.ts:176

`Protected`getProductData

getProductData(
product: ProductBuilder<Product>,
): Promise<void | ProductBuilder<Product>>

Transforms a Shopify product listing into the common Product type.

Parameters

product: ProductBuilder<Product>
The Shopify product listing to transform

Returns Promise<void | ProductBuilder<Product>>

Promise resolving to a partial Product object or void if invalid

Example

const products = await this.queryProducts("sodium chloride");
if (products) {
  const product = await this.getProductData(products[0]);
  if (product) {
    const builtProduct = await product.build();
    console.log({
      title: builtProduct.title,
      price: builtProduct.price,
      quantity: builtProduct.quantity,
      uom: builtProduct.uom,
      variants: builtProduct.variants
    });
  }
}

`Protected`titleSelector

titleSelector(data: ItemListing): string
Selects the title of a product from the search response
Parameters
- data: ItemListing
  Product object from search response
Returns string
- The title of the product
Inherited from SupplierBaseShopify.titleSelector
- Defined in src/suppliers/SupplierBaseShopify.ts:260

Properties

`Protected`query

query: string

String to query for (Product name, CAS, etc). This is the search term that will be used to find products. Set during construction and used throughout the supplier's lifecycle.

Example

const supplier = new MySupplier("sodium chloride", 10);
console.log(supplier.query); // "sodium chloride"

`Protected`queryResults

queryResults: ItemListing[] = []

If the products first require a query of a search page that gets iterated over, those results are stored here. This acts as a cache for the initial search results before they are processed into full product objects.

Example

// After a search query
await supplier.queryProducts("acetone");
console.log(`Found ${supplier.queryResults.length} initial results`);

`Protected`baseSearchParams

baseSearchParams: Record<string, string | number> = {}

The base search parameters that are always included in search requests. These parameters are merged with any additional search parameters when making requests to the supplier's API.

Example

class MySupplier extends SupplierBase<Product> {
  constructor() {
    super();
    this.baseSearchParams = {
      format: "json",
      version: "2.0"
    };
  }
}

`Protected`controller

controller: AbortController

The AbortController instance used to manage and cancel ongoing requests. This allows for cancellation of in-flight requests when needed, such as when a new search is started or the supplier is disposed.

Example

const controller = new AbortController();
const supplier = new MySupplier("acetone", 5, controller);

// Later, to cancel all pending requests:
controller.abort();

`Protected`limit

limit: number

The maximum number of results to return for a search query. This is not a limit on HTTP requests, but rather the number of products that will be returned to the caller.

Example

const supplier = new MySupplier("acetone", 5); // Limit to 5 results
for await (const product of supplier) {
  // Will yield at most 5 products
}

`Protected`products

products: ProductBuilder<Product>[] = []

The products that are currently being built by the supplier. This array holds ProductBuilder instances that are in the process of being transformed into complete Product objects.

Example

await supplier.queryProducts("acetone");
console.log(`Building ${supplier.products.length} products`);
for (const builder of supplier.products) {
  const product = await builder.build();
  console.log("Built product:", product.title);
}

`Protected`httpRequestHardLimit

httpRequestHardLimit: number = 50

Maximum number of HTTP requests allowed per search query. This is a hard limit to prevent excessive requests to the supplier's API. If this limit is reached, the supplier will stop making new requests.

Default Value

Example

class MySupplier extends SupplierBase<Product> {
  constructor() {
    super();
    this.httpRequestHardLimit = 100; // Allow more requests
  }
}

`Protected`requestCount

requestCount: number = 0

Counter for HTTP requests made during the current query execution. This is used to track the number of requests and ensure we don't exceed the httpRequestHardLimit.

Default Value

Example

await supplier.queryProducts("acetone");
console.log(`Made ${supplier.requestCount} requests`);
if (supplier.requestCount >= supplier.httpRequestHardLimit) {
  console.log("Reached request limit");
}

`Protected`maxConcurrentRequests

maxConcurrentRequests: number = 3

Number of requests to process in parallel when fetching product details. This controls the batch size for concurrent requests to avoid overwhelming the supplier's API and the user's bandwidth.

Default Value

Example

class MySupplier extends SupplierBase<Product> {
  constructor() {
    super();
    // Process 5 requests at a time
    this.maxConcurrentRequests = 5;
  }
}

`Protected`minConcurrentCycle

minConcurrentCycle: number = 100

Minimum number of milliseconds between two consecutive tasks

`Protected`headers

headers: HeadersInit = {}

HTTP headers used as a basis for all requests to the supplier. These headers are merged with any request-specific headers when making HTTP requests.

Example

class MySupplier extends SupplierBase<Product> {
  constructor() {
    super();
    this.headers = {
      "Accept": "application/json",
      "User-Agent": "ChemCrawler/1.0"
    };
  }
}

`Protected`logger

logger: Logger

`Protected`productDefaults

productDefaults: {
    uom: string;
    quantity: number;
    currencyCode: string;
    currencySymbol: string;
} = ...

`Protected` `Static` `Readonly`productDataCacheKey

productDataCacheKey: "supplier_product_data_cache"

`Protected`cache

cache: SupplierCache

`Protected`apiHost

apiHost: string = "searchserverapi.com"

`Readonly`supplierName

supplierName: string = "Laballey"

The name of the supplier

`Readonly`baseURL

baseURL: string = "https://www.laballey.com"

The base URL for the supplier

`Readonly`shipping

shipping: ShippingRange = "international"

The shipping scope of the supplier. This is used to determine the shipping scope of the supplier.

`Readonly`country

country: string = "US"

The country code of the supplier. This is used to determine the currency and other country-specific information.

`Protected`apiKey

apiKey: string = "8B7o0X1o7c"

`Readonly`paymentMethods

paymentMethods: PaymentMethod[] = ...

The payment methods accepted by the supplier. This is used to determine the payment methods accepted by the supplier.

Class SupplierLaballey

Hierarchy (View Summary)

Implements

Index

Constructors

Methods

Properties

Constructors

constructor

Parameters

Returns SupplierLaballey

Example

Methods

initCache

Returns void

Remarks

Example

Protectedsetup

Returns Promise<void>

Example

ProtectedhttpGetHeaders

Parameters

Returns Promise<Maybe<HeadersInit>>

Example

Example

ProtectedhttpPost

Parameters

Returns Promise<Maybe<Response>>

Example

Example

Example

Example

ProtectedhttpPostJson

Parameters

Returns Promise<Maybe<JsonValue>>

Example

Example

ProtectedhttpPostHtml

Parameters

Returns Promise<Maybe<string>>

Throws

Example

ProtectedhttpGet

Parameters

Returns Promise<Maybe<Response>>

Example

Example

Example

Example

ProtectedfuzzyFilter

Type Parameters

Parameters

Returns X[]

Example

ProtectedhttpGetHtml

Parameters

Returns Promise<Maybe<string>>

Throws

Example

ProtectedhttpGetJson

Parameters

Returns Promise<Maybe<JsonValue>>

Throws

Example

Example

Example

Example

ProtectedqueryProductsWithCache

Parameters

Returns Promise<void | ProductBuilder<Product>[]>

Example

Example

execute

Returns AsyncGenerator<Product, void, undefined>

Remarks

ProtectedfinishProduct

Parameters

Returns Promise<Maybe<Product>>

Example

Protectedhref

`Protected`setup

`Protected`httpGetHeaders

`Protected`httpPost

`Protected`httpPostJson

`Protected`httpPostHtml

`Protected`httpGet

`Protected`fuzzyFilter

`Protected`httpGetHtml

`Protected`httpGetJson

`Protected`queryProductsWithCache

`Protected`finishProduct

`Protected`href

`Protected`getProductDataWithCache

`Protected`groupVariants

`Protected`fetch

`Protected`queryProducts

`Protected`initProductBuilders

`Protected`getProductData

`Protected`titleSelector

`Protected`query

`Protected`queryResults

`Protected`baseSearchParams

`Protected`controller

`Protected`limit

`Protected`products

`Protected`httpRequestHardLimit

`Protected`requestCount

`Protected`maxConcurrentRequests

`Protected`minConcurrentCycle

`Protected`headers

`Protected`logger

`Protected`productDefaults

`Protected` `Static` `Readonly`productDataCacheKey

`Protected`cache

`Protected`apiHost

`Readonly`supplierName

`Readonly`baseURL

`Readonly`shipping

`Readonly`country

`Protected`apiKey

`Readonly`paymentMethods