shop-client 3.9.0 → 3.9.2

package/README.md

@@ -622,6 +622,45 @@ Notes:
 - npm publishes use OIDC with provenance; no `NPM_TOKEN` secret is required.
 - Ensure your npm package settings add this GitHub repo as a trusted publisher and set the environment name to `npm-publish`.
 
+### Additional Utilities
+
+```typescript
+import {
+  calculateDiscount,
+  extractDomainWithoutSuffix,
+  generateStoreSlug,
+  genProductSlug,
+  detectShopCountry,
+} from 'shop-client';
+
+// Discount calculation (percentage, rounded to nearest integer)
+calculateDiscount(8000, 10000); // 20
+
+// Extract base domain without public suffix
+extractDomainWithoutSuffix('www.example.co.uk'); // 'example'
+
+// Create an SEO-friendly store slug
+generateStoreSlug('https://shop.example.com'); // 'shop-example-com'
+
+// Create a product slug from product data
+genProductSlug({
+  title: 'Summer Dress',
+  handle: 'summer-dress',
+  vendor: 'Acme',
+}); // 'acme-summer-dress'
+
+// Detect Shopify store country with confidence score
+const result = await detectShopCountry('anuki.in');
+// result.country → 'IN', result.confidence → 0.9
+```
+
+Notes:
+- `calculateDiscount` expects prices in the same unit (e.g., cents) and returns an integer percentage.
+- `extractDomainWithoutSuffix` removes known TLDs/suffixes, leaving the registrable label.
+- `generateStoreSlug` preserves domain components and replaces separators with hyphens.
+- `genProductSlug` builds a stable, vendor-prefixed slug using product fields.
+- `detectShopCountry` combines multiple signals to infer store country and confidence.
+
 ### Store Type Classification
 
 Determine the store’s primary verticals and target audiences using showcased products. Classification uses only each product’s `body_html` content and aggregates per-product results, optionally pruned by store-level signals.
@@ -657,6 +696,32 @@ Details:
 - If `OPENROUTER_API_KEY` is absent or `OPENROUTER_OFFLINE=1`, uses offline regex heuristics.
 - Applies store-level pruning based on title/description to improve consistency.
 
+### AI Enrichment
+
+```typescript
+import { classifyProduct, generateSEOContent } from 'shop-client';
+
+// Classify a single product (offline or via OpenRouter when configured)
+const classification = await classifyProduct({
+  title: 'Organic Cotton T-Shirt',
+  bodyHtml: '<p>Soft, breathable cotton tee</p>',
+  tags: ['organic', 'cotton', 'unisex'],
+});
+// classification → { adult_unisex: { clothing: ['t-shirts'] } }
+
+// Generate basic SEO content for a product
+const seo = await generateSEOContent({
+  title: 'Organic Cotton T-Shirt',
+  description: 'Soft, breathable tee for everyday wear',
+  tags: ['organic', 'cotton', 'unisex'],
+});
+// seo.metaTitle, seo.metaDescription, seo.keywords
+```
+
+Notes:
+- `classifyProduct` mirrors the store-level classification logic but operates on a single product.
+- `generateSEOContent` produces lightweight, deterministic metadata suitable for catalogs and PDPs.
+
 ## 🏗️ Type Definitions
 
 ### StoreInfo

package/dist/ai/enrich.d.ts

@@ -0,0 +1,93 @@
+import { k as ProductClassification, l as SEOContent, a as ShopifySingleProduct } from '../types-luPg5O08.js';
+
+interface EnrichedProductResult {
+    bodyHtml: string;
+    pageHtml: string;
+    extractedMainHtml: string;
+    mergedMarkdown: string;
+}
+/**
+ * Fetch Shopify Product AJAX API
+ * /products/{handle}.js
+ */
+declare function fetchAjaxProduct(domain: string, handle: string): Promise<ShopifySingleProduct>;
+/**
+ * Fetch full product page HTML
+ */
+declare function fetchProductPage(domain: string, handle: string): Promise<string>;
+/**
+ * Extract the main Shopify product section WITHOUT cheerio
+ * Uses regex + indexing (fast & reliable)
+ */
+declare function extractMainSection(html: string): string | null;
+/**
+ * Convert HTML → Clean Markdown using Turndown
+ * Includes Shopify cleanup rules + GFM support
+ */
+declare function htmlToMarkdown(html: string | null, options?: {
+    useGfm?: boolean;
+}): string;
+/**
+ * Merge the two markdown sources using OpenAI GPT
+ */
+declare function mergeWithLLM(bodyInput: string, pageInput: string, options?: {
+    apiKey?: string;
+    inputType?: "markdown" | "html";
+    model?: string;
+    outputFormat?: "markdown" | "json";
+}): Promise<string>;
+/**
+ * MAIN WORKFLOW
+ */
+declare function enrichProduct(domain: string, handle: string, options?: {
+    apiKey?: string;
+    useGfm?: boolean;
+    inputType?: "markdown" | "html";
+    model?: string;
+    outputFormat?: "markdown" | "json";
+}): Promise<EnrichedProductResult>;
+/**
+ * Classify product content into a three-tier hierarchy using LLM.
+ * Returns strictly validated JSON with audience, vertical, and optional category/subCategory.
+ */
+declare function classifyProduct(productContent: string, options?: {
+    apiKey?: string;
+    model?: string;
+}): Promise<ProductClassification>;
+/**
+ * Generate SEO and marketing content for a product. Returns strictly validated JSON.
+ */
+declare function generateSEOContent(product: {
+    title: string;
+    description?: string;
+    vendor?: string;
+    price?: number;
+    tags?: string[];
+}, options?: {
+    apiKey?: string;
+    model?: string;
+}): Promise<SEOContent>;
+/**
+ * Determine store type (primary vertical and audience) from store information.
+ * Accepts flexible input for showcase products/collections (titles or handles) and returns
+ * strictly validated `vertical` and `audience` values.
+ */
+declare function determineStoreType(storeInfo: {
+    title: string;
+    description?: string | null;
+    showcase: {
+        products: Array<{
+            title: string;
+            productType?: string | null;
+        }> | string[];
+        collections: Array<{
+            title: string;
+        }> | string[];
+    };
+}, options?: {
+    apiKey?: string;
+    model?: string;
+}): Promise<Partial<Record<ProductClassification["audience"], Partial<Record<ProductClassification["vertical"], string[]>>>>>;
+declare function pruneBreakdownForSignals(breakdown: Partial<Record<ProductClassification["audience"], Partial<Record<ProductClassification["vertical"], string[]>>>>, text: string): Partial<Record<ProductClassification["audience"], Partial<Record<ProductClassification["vertical"], string[]>>>>;
+
+export { type EnrichedProductResult, classifyProduct, determineStoreType, enrichProduct, extractMainSection, fetchAjaxProduct, fetchProductPage, generateSEOContent, htmlToMarkdown, mergeWithLLM, pruneBreakdownForSignals };

package/dist/ai/enrich.js

@@ -0,0 +1,25 @@
+import {
+  classifyProduct,
+  determineStoreType,
+  enrichProduct,
+  extractMainSection,
+  fetchAjaxProduct,
+  fetchProductPage,
+  generateSEOContent,
+  htmlToMarkdown,
+  mergeWithLLM,
+  pruneBreakdownForSignals
+} from "../chunk-VPPCOJC3.js";
+import "../chunk-2MF53V33.js";
+export {
+  classifyProduct,
+  determineStoreType,
+  enrichProduct,
+  extractMainSection,
+  fetchAjaxProduct,
+  fetchProductPage,
+  generateSEOContent,
+  htmlToMarkdown,
+  mergeWithLLM,
+  pruneBreakdownForSignals
+};

package/dist/checkout.js

@@ -0,0 +1,6 @@
+import {
+  createCheckoutOperations
+} from "./chunk-RR6YTQWP.js";
+export {
+  createCheckoutOperations
+};

package/dist/chunk-2MF53V33.js

@@ -0,0 +1,196 @@
+// src/utils/rate-limit.ts
+var RateLimiter = class {
+  constructor(options) {
+    this.queue = [];
+    this.inFlight = 0;
+    this.refillTimer = null;
+    this.options = options;
+    this.tokens = options.maxRequestsPerInterval;
+  }
+  startRefill() {
+    if (this.refillTimer) return;
+    this.refillTimer = setInterval(() => {
+      this.tokens = this.options.maxRequestsPerInterval;
+      this.tryRun();
+    }, this.options.intervalMs);
+    if (this.refillTimer && typeof this.refillTimer.unref === "function") {
+      this.refillTimer.unref();
+    }
+  }
+  ensureRefillStarted() {
+    if (!this.refillTimer) {
+      this.startRefill();
+    }
+  }
+  configure(next) {
+    this.options = { ...this.options, ...next };
+    this.options.maxRequestsPerInterval = Math.max(
+      1,
+      this.options.maxRequestsPerInterval
+    );
+    this.options.intervalMs = Math.max(10, this.options.intervalMs);
+    this.options.maxConcurrency = Math.max(1, this.options.maxConcurrency);
+  }
+  schedule(fn) {
+    return new Promise((resolve, reject) => {
+      this.ensureRefillStarted();
+      this.queue.push({ fn, resolve, reject });
+      this.tryRun();
+    });
+  }
+  tryRun() {
+    while (this.queue.length > 0 && this.inFlight < this.options.maxConcurrency && this.tokens > 0) {
+      const task = this.queue.shift();
+      this.tokens -= 1;
+      this.inFlight += 1;
+      Promise.resolve().then(task.fn).then((result) => task.resolve(result)).catch((err) => task.reject(err)).finally(() => {
+        this.inFlight -= 1;
+        setTimeout(() => this.tryRun(), 0);
+      });
+    }
+  }
+};
+var enabled = false;
+var defaultOptions = {
+  maxRequestsPerInterval: 5,
+  // 5 requests
+  intervalMs: 1e3,
+  // per second
+  maxConcurrency: 5
+  // up to 5 in parallel
+};
+var limiter = new RateLimiter(defaultOptions);
+var hostLimiters = /* @__PURE__ */ new Map();
+var classLimiters = /* @__PURE__ */ new Map();
+function getHost(input) {
+  try {
+    if (typeof input === "string") {
+      return new URL(input).host;
+    }
+    if (input instanceof URL) {
+      return input.host;
+    }
+    const url = input.url;
+    if (url) {
+      return new URL(url).host;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getHostLimiter(host) {
+  if (!host) return void 0;
+  const exact = hostLimiters.get(host);
+  if (exact) return exact;
+  for (const [key, lim] of hostLimiters.entries()) {
+    if (key.startsWith("*.") && host.endsWith(key.slice(2))) {
+      return lim;
+    }
+  }
+  return void 0;
+}
+function configureRateLimit(options) {
+  var _a, _b, _c, _d, _e, _f;
+  if (typeof options.enabled === "boolean") {
+    enabled = options.enabled;
+  }
+  const { perHost, perClass } = options;
+  const globalOpts = {};
+  if (typeof options.maxRequestsPerInterval === "number") {
+    globalOpts.maxRequestsPerInterval = options.maxRequestsPerInterval;
+  }
+  if (typeof options.intervalMs === "number") {
+    globalOpts.intervalMs = options.intervalMs;
+  }
+  if (typeof options.maxConcurrency === "number") {
+    globalOpts.maxConcurrency = options.maxConcurrency;
+  }
+  if (Object.keys(globalOpts).length) {
+    limiter.configure(globalOpts);
+  }
+  if (perHost) {
+    for (const host of Object.keys(perHost)) {
+      const opts = perHost[host];
+      const existing = hostLimiters.get(host);
+      if (existing) {
+        existing.configure(opts);
+      } else {
+        hostLimiters.set(
+          host,
+          new RateLimiter({
+            maxRequestsPerInterval: (_a = opts.maxRequestsPerInterval) != null ? _a : defaultOptions.maxRequestsPerInterval,
+            intervalMs: (_b = opts.intervalMs) != null ? _b : defaultOptions.intervalMs,
+            maxConcurrency: (_c = opts.maxConcurrency) != null ? _c : defaultOptions.maxConcurrency
+          })
+        );
+      }
+    }
+  }
+  if (perClass) {
+    for (const klass of Object.keys(perClass)) {
+      const opts = perClass[klass];
+      const existing = classLimiters.get(klass);
+      if (existing) {
+        existing.configure(opts);
+      } else {
+        classLimiters.set(
+          klass,
+          new RateLimiter({
+            maxRequestsPerInterval: (_d = opts.maxRequestsPerInterval) != null ? _d : defaultOptions.maxRequestsPerInterval,
+            intervalMs: (_e = opts.intervalMs) != null ? _e : defaultOptions.intervalMs,
+            maxConcurrency: (_f = opts.maxConcurrency) != null ? _f : defaultOptions.maxConcurrency
+          })
+        );
+      }
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function rateLimitedFetch(input, init) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const klass = init == null ? void 0 : init.rateLimitClass;
+  const byClass = klass ? classLimiters.get(klass) : void 0;
+  const byHost = getHostLimiter(getHost(input));
+  const eff = enabled ? (_a = byClass != null ? byClass : byHost) != null ? _a : limiter : void 0;
+  const maxRetries = Math.max(0, (_c = (_b = init == null ? void 0 : init.retry) == null ? void 0 : _b.maxRetries) != null ? _c : 2);
+  const baseDelayMs = Math.max(0, (_e = (_d = init == null ? void 0 : init.retry) == null ? void 0 : _d.baseDelayMs) != null ? _e : 200);
+  const retryOnStatuses = (_g = (_f = init == null ? void 0 : init.retry) == null ? void 0 : _f.retryOnStatuses) != null ? _g : [429, 503];
+  let attempt = 0;
+  let lastError = null;
+  let response = null;
+  while (attempt <= maxRetries) {
+    try {
+      if (eff) {
+        response = await eff.schedule(() => fetch(input, init));
+      } else {
+        response = await fetch(input, init);
+      }
+      if (!response || response.ok || !retryOnStatuses.includes(response.status)) {
+        return response;
+      }
+    } catch (err) {
+      lastError = err;
+    }
+    attempt += 1;
+    if (attempt > maxRetries) break;
+    const jitter = Math.floor(Math.random() * 100);
+    const delay = baseDelayMs * 2 ** (attempt - 1) + jitter;
+    await sleep(delay);
+  }
+  if (response) return response;
+  throw lastError != null ? lastError : new Error("rateLimitedFetch failed without response");
+}
+function getRateLimitStatus() {
+  return {
+    enabled,
+    options: { ...defaultOptions }
+  };
+}
+
+export {
+  configureRateLimit,
+  rateLimitedFetch,
+  getRateLimitStatus
+};

package/dist/chunk-CN7L3BHG.js

@@ -0,0 +1,147 @@
+// src/utils/func.ts
+import { parse } from "tldts";
+function extractDomainWithoutSuffix(domain) {
+  const parsedDomain = parse(domain);
+  return parsedDomain.domainWithoutSuffix;
+}
+function generateStoreSlug(domain) {
+  var _a;
+  const input = new URL(domain);
+  const parsedDomain = parse(input.href);
+  const domainName = (_a = parsedDomain.domainWithoutSuffix) != null ? _a : input.hostname.split(".")[0];
+  return (domainName || "").toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+var genProductSlug = ({
+  handle,
+  storeDomain
+}) => {
+  const storeSlug = generateStoreSlug(storeDomain);
+  return `${handle}-by-${storeSlug}`;
+};
+var calculateDiscount = (price, compareAtPrice) => !compareAtPrice || compareAtPrice === 0 ? 0 : Math.max(
+  0,
+  Math.round(100 - price / compareAtPrice * 100)
+  // Removed the decimal precision
+);
+function sanitizeDomain(input, opts) {
+  var _a;
+  if (typeof input !== "string") {
+    throw new Error("sanitizeDomain: input must be a string");
+  }
+  let raw = input.trim();
+  if (!raw) {
+    throw new Error("sanitizeDomain: input cannot be empty");
+  }
+  const hasProtocol = /^[a-z]+:\/\//i.test(raw);
+  if (!hasProtocol && !raw.startsWith("//")) {
+    raw = `https://${raw}`;
+  }
+  const stripWWW = (_a = opts == null ? void 0 : opts.stripWWW) != null ? _a : true;
+  try {
+    let url;
+    if (raw.startsWith("//")) {
+      url = new URL(`https:${raw}`);
+    } else if (raw.includes("://")) {
+      url = new URL(raw);
+    } else {
+      url = new URL(`https://${raw}`);
+    }
+    let hostname = url.hostname.toLowerCase();
+    const hadWWW = /^www\./i.test(url.hostname);
+    if (stripWWW) hostname = hostname.replace(/^www\./, "");
+    if (!hostname.includes(".")) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    const parsed = parse(hostname);
+    if (!parsed.publicSuffix || parsed.isIcann === false) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    if (!stripWWW && hadWWW) {
+      return `www.${parsed.domain || hostname}`;
+    }
+    return parsed.domain || hostname;
+  } catch {
+    let hostname = raw.toLowerCase();
+    hostname = hostname.replace(/^[a-z]+:\/\//, "");
+    hostname = hostname.replace(/^\/\//, "");
+    hostname = hostname.replace(/[/:#?].*$/, "");
+    const hadWWW = /^www\./i.test(hostname);
+    if (stripWWW) hostname = hostname.replace(/^www\./, "");
+    if (!hostname.includes(".")) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    const parsed = parse(hostname);
+    if (!parsed.publicSuffix || parsed.isIcann === false) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    if (!stripWWW && hadWWW) {
+      return `www.${parsed.domain || hostname}`;
+    }
+    return parsed.domain || hostname;
+  }
+}
+function safeParseDate(input) {
+  if (!input || typeof input !== "string") return void 0;
+  const d = new Date(input);
+  return Number.isNaN(d.getTime()) ? void 0 : d;
+}
+function normalizeKey(input) {
+  return input.toLowerCase().replace(/\s+/g, "_");
+}
+function buildVariantOptionsMap(optionNames, variants) {
+  const keys = optionNames.map(normalizeKey);
+  const map = {};
+  for (const v of variants) {
+    const parts = [];
+    if (keys[0] && v.option1)
+      parts.push(`${keys[0]}#${normalizeKey(v.option1)}`);
+    if (keys[1] && v.option2)
+      parts.push(`${keys[1]}#${normalizeKey(v.option2)}`);
+    if (keys[2] && v.option3)
+      parts.push(`${keys[2]}#${normalizeKey(v.option3)}`);
+    if (parts.length > 0) {
+      if (parts.length > 1) parts.sort();
+      const key = parts.join("##");
+      const id = v.id.toString();
+      if (map[key] === void 0) {
+        map[key] = id;
+      }
+    }
+  }
+  return map;
+}
+function buildVariantKey(obj) {
+  const parts = [];
+  for (const [name, value] of Object.entries(obj)) {
+    if (value) {
+      parts.push(`${normalizeKey(name)}#${normalizeKey(value)}`);
+    }
+  }
+  if (parts.length === 0) return "";
+  parts.sort((a, b) => a.localeCompare(b));
+  return parts.join("##");
+}
+function formatPrice(amountInCents, currency) {
+  try {
+    return new Intl.NumberFormat(void 0, {
+      style: "currency",
+      currency
+    }).format((amountInCents || 0) / 100);
+  } catch {
+    const val = (amountInCents || 0) / 100;
+    return `${val} ${currency}`;
+  }
+}
+
+export {
+  extractDomainWithoutSuffix,
+  generateStoreSlug,
+  genProductSlug,
+  calculateDiscount,
+  sanitizeDomain,
+  safeParseDate,
+  normalizeKey,
+  buildVariantOptionsMap,
+  buildVariantKey,
+  formatPrice
+};