@react-pakistan/util-functions 1.25.11 → 1.25.13

package/constants/cache-time.d.ts

@@ -1,3 +1,5 @@
 export declare const ONE_DAY_IN_MS: number;
 export declare const ONE_WEEK_IN_MS: number;
 export declare const ONE_MONTH_IN_MS: number;
+export declare const SIX_MONTHS_IN_MS: number;
+export declare const ONE_YEAR_IN_MS: number;

package/constants/cache-time.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ONE_MONTH_IN_MS = exports.ONE_WEEK_IN_MS = exports.ONE_DAY_IN_MS = void 0;
+exports.ONE_YEAR_IN_MS = exports.SIX_MONTHS_IN_MS = exports.ONE_MONTH_IN_MS = exports.ONE_WEEK_IN_MS = exports.ONE_DAY_IN_MS = void 0;
 exports.ONE_DAY_IN_MS = 1 * 24 * 60 * 60 * 1000; // 1 day in milliseconds
 exports.ONE_WEEK_IN_MS = 7 * 24 * 60 * 60 * 1000; // 1 week in milliseconds
 exports.ONE_MONTH_IN_MS = 30 * 24 * 60 * 60 * 1000; // 1 month in milliseconds
+exports.SIX_MONTHS_IN_MS = 6 * 30 * 24 * 60 * 60 * 1000; // 6 months in milliseconds
+exports.ONE_YEAR_IN_MS = 12 * 30 * 24 * 60 * 60 * 1000; // 1 year in milliseconds

package/general/generate-article-schema.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Generate schema.org JSON-LD for `Article`, `NewsArticle`, or `BlogPosting`.
+ *
+ * This helper accepts `ArticleSchema` inputs and formats authors,
+ * publisher/logo, images, and optional fields such as `keywords`,
+ * `articleSection`, and `wordCount`. Only supplied fields are emitted in
+ * the resulting object, making the output safe to merge into page
+ * metadata bundles.
+ *
+ * Examples are provided in the interface comments below — consult the
+ * `ArticleSchema` type for full details of supported inputs.
+ *
+ * @param options - Article metadata and optional fields
+ * @returns A JSON-LD compatible Article/NewsArticle/BlogPosting object
+ */
+type ArticleType = 'Article' | 'NewsArticle' | 'BlogPosting';
+interface ArticleAuthor {
+    name: string;
+    url?: string;
+}
+interface ArticleImage {
+    url: string;
+    width?: number;
+    height?: number;
+}
+interface ArticlePublisher {
+    name: string;
+    logo?: {
+        url: string;
+        width?: number;
+        height?: number;
+    };
+}
+interface ArticleSchema {
+    type?: ArticleType;
+    headline: string;
+    description?: string;
+    image: string | string[] | ArticleImage | ArticleImage[];
+    author: string | ArticleAuthor | ArticleAuthor[];
+    publisher: ArticlePublisher;
+    datePublished: string;
+    dateModified?: string;
+    url?: string;
+    keywords?: string[];
+    articleSection?: string;
+    wordCount?: number;
+}
+export declare const generateArticleSchema: ({ type, headline, description, image, author, publisher, datePublished, dateModified, url, keywords, articleSection, wordCount, }: ArticleSchema) => any;
+export {};

package/general/generate-article-schema.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Generate schema.org JSON-LD for `Article`, `NewsArticle`, or `BlogPosting`.
+ *
+ * This helper accepts `ArticleSchema` inputs and formats authors,
+ * publisher/logo, images, and optional fields such as `keywords`,
+ * `articleSection`, and `wordCount`. Only supplied fields are emitted in
+ * the resulting object, making the output safe to merge into page
+ * metadata bundles.
+ *
+ * Examples are provided in the interface comments below — consult the
+ * `ArticleSchema` type for full details of supported inputs.
+ *
+ * @param options - Article metadata and optional fields
+ * @returns A JSON-LD compatible Article/NewsArticle/BlogPosting object
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateArticleSchema = void 0;
+var formatAuthor = function (author) {
+    if (typeof author === 'string') {
+        return {
+            '@type': 'Person',
+            name: author,
+        };
+    }
+    if (Array.isArray(author)) {
+        return author.map(function (a) { return (__assign({ '@type': 'Person', name: a.name }, (a.url && { url: a.url }))); });
+    }
+    return __assign({ '@type': 'Person', name: author.name }, (author.url && { url: author.url }));
+};
+var formatImage = function (image) {
+    if (typeof image === 'string') {
+        return image;
+    }
+    if (Array.isArray(image)) {
+        return image.map(function (img) {
+            if (typeof img === 'string') {
+                return img;
+            }
+            return __assign(__assign({ '@type': 'ImageObject', url: img.url }, (img.width && { width: img.width })), (img.height && { height: img.height }));
+        });
+    }
+    return __assign(__assign({ '@type': 'ImageObject', url: image.url }, (image.width && { width: image.width })), (image.height && { height: image.height }));
+};
+var formatPublisher = function (publisher) {
+    var publisherData = {
+        '@type': 'Organization',
+        name: publisher.name,
+    };
+    if (publisher.logo) {
+        publisherData.logo = __assign(__assign({ '@type': 'ImageObject', url: publisher.logo.url }, (publisher.logo.width && { width: publisher.logo.width })), (publisher.logo.height && { height: publisher.logo.height }));
+    }
+    return publisherData;
+};
+var generateArticleSchema = function (_a) {
+    var _b = _a.type, type = _b === void 0 ? 'Article' : _b, headline = _a.headline, description = _a.description, image = _a.image, author = _a.author, publisher = _a.publisher, datePublished = _a.datePublished, dateModified = _a.dateModified, url = _a.url, keywords = _a.keywords, articleSection = _a.articleSection, wordCount = _a.wordCount;
+    var schema = {
+        '@context': 'https://schema.org',
+        '@type': type,
+        headline: headline,
+        image: formatImage(image),
+        author: formatAuthor(author),
+        publisher: formatPublisher(publisher),
+        datePublished: datePublished,
+    };
+    if (description) {
+        schema.description = description;
+    }
+    if (dateModified) {
+        schema.dateModified = dateModified;
+    }
+    if (url) {
+        schema.mainEntityOfPage = {
+            '@type': 'WebPage',
+            '@id': url,
+        };
+    }
+    if (keywords && keywords.length > 0) {
+        schema.keywords = keywords.join(', ');
+    }
+    if (articleSection) {
+        schema.articleSection = articleSection;
+    }
+    if (wordCount) {
+        schema.wordCount = wordCount;
+    }
+    return schema;
+};
+exports.generateArticleSchema = generateArticleSchema;

package/general/generate-blog-schema.d.ts

@@ -1,11 +1,13 @@
 /**
- * A util function to create Rich Schema for FAQ
+ * Generate schema.org `BlogPosting` JSON-LD for a blog entry.
  *
- * @returns formatted date - Saturday, 11/01/2020
- * @author Taimoor Khan
- * @remarks AppCorp
+ * Produces a compact `BlogPosting` object using headline, dates, image and
+ * author information. Only provided fields are emitted, and the returned
+ * object is ready to be stringified as JSON-LD.
+ *
+ * See the `Blog` interface below for the accepted properties.
+ * @returns A JSON-LD compatible `BlogPosting` object
  */
-/** End file docs */
 interface Blog {
     authorImage: string;
     authorName: string;

package/general/generate-blog-schema.js

@@ -1,12 +1,14 @@
 "use strict";
 /**
- * A util function to create Rich Schema for FAQ
+ * Generate schema.org `BlogPosting` JSON-LD for a blog entry.
  *
- * @returns formatted date - Saturday, 11/01/2020
- * @author Taimoor Khan
- * @remarks AppCorp
+ * Produces a compact `BlogPosting` object using headline, dates, image and
+ * author information. Only provided fields are emitted, and the returned
+ * object is ready to be stringified as JSON-LD.
+ *
+ * See the `Blog` interface below for the accepted properties.
+ * @returns A JSON-LD compatible `BlogPosting` object
  */
-/** End file docs */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateBlogSchema = void 0;
 var generateBlogSchema = function (_a) {

package/general/generate-book-schema.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Generate schema.org `Book` JSON-LD for use in page <script type="application/ld+json">.
+ *
+ * This helper accepts a compact `BookSchemaOptions` input and returns a
+ * plain object ready to be stringified and inlined on a page. Common
+ * fields supported:
+ *
+ * - `title` → maps to `name`
+ * - `author` → accepts a `string`, an `{ name, url? }` object, or an array of
+ *   those; these are formatted as `Person` objects
+ * - `publisher` → `{ name, logo? }` formatted as an `Organization` with
+ *   an optional `ImageObject` logo
+ * - `image` → accepts a `string`, `BookImage` or arrays; non-string images are
+ *   converted to `ImageObject` entries
+ * - `url` → attached to `mainEntityOfPage.@id` when provided
+ * - `keywords` → joined into a comma-separated string
+ *
+ * The implementation intentionally produces minimal output (only provided
+ * fields are added) so the result can be safely merged into other page
+ * metadata.
+ *
+ * @param options.book title, author, publisher and optional metadata
+ * @returns A JSON-LD compatible `Book` object
+ */
+interface BookAuthor {
+    name: string;
+    url?: string;
+}
+interface BookImage {
+    url: string;
+    width?: number;
+    height?: number;
+}
+interface BookPublisher {
+    name: string;
+    logo?: {
+        url: string;
+        width?: number;
+        height?: number;
+    };
+}
+interface BookSchemaOptions {
+    title: string;
+    author: string | BookAuthor | BookAuthor[];
+    isbn?: string;
+    numberOfPages?: number;
+    inLanguage?: string;
+    publisher: BookPublisher;
+    datePublished?: string;
+    image?: string | string[] | BookImage | BookImage[];
+    description?: string;
+    url?: string;
+    keywords?: string[];
+    bookFormat?: string;
+}
+export declare const generateBookSchema: ({ title, author, isbn, numberOfPages, inLanguage, publisher, datePublished, image, description, url, keywords, bookFormat, }: BookSchemaOptions) => any;
+export {};

package/general/generate-book-schema.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Generate schema.org `Book` JSON-LD for use in page <script type="application/ld+json">.
+ *
+ * This helper accepts a compact `BookSchemaOptions` input and returns a
+ * plain object ready to be stringified and inlined on a page. Common
+ * fields supported:
+ *
+ * - `title` → maps to `name`
+ * - `author` → accepts a `string`, an `{ name, url? }` object, or an array of
+ *   those; these are formatted as `Person` objects
+ * - `publisher` → `{ name, logo? }` formatted as an `Organization` with
+ *   an optional `ImageObject` logo
+ * - `image` → accepts a `string`, `BookImage` or arrays; non-string images are
+ *   converted to `ImageObject` entries
+ * - `url` → attached to `mainEntityOfPage.@id` when provided
+ * - `keywords` → joined into a comma-separated string
+ *
+ * The implementation intentionally produces minimal output (only provided
+ * fields are added) so the result can be safely merged into other page
+ * metadata.
+ *
+ * @param options.book title, author, publisher and optional metadata
+ * @returns A JSON-LD compatible `Book` object
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBookSchema = void 0;
+var formatAuthor = function (author) {
+    if (typeof author === 'string') {
+        return {
+            '@type': 'Person',
+            name: author,
+        };
+    }
+    if (Array.isArray(author)) {
+        return author.map(function (a) { return (__assign({ '@type': 'Person', name: a.name }, (a.url && { url: a.url }))); });
+    }
+    return __assign({ '@type': 'Person', name: author.name }, (author.url && { url: author.url }));
+};
+var formatImage = function (image) {
+    if (!image)
+        return undefined;
+    if (typeof image === 'string')
+        return image;
+    if (Array.isArray(image)) {
+        return image.map(function (img) {
+            if (typeof img === 'string')
+                return img;
+            return __assign(__assign({ '@type': 'ImageObject', url: img.url }, (img.width && { width: img.width })), (img.height && { height: img.height }));
+        });
+    }
+    return __assign(__assign({ '@type': 'ImageObject', url: image.url }, (image.width && { width: image.width })), (image.height && { height: image.height }));
+};
+var formatPublisher = function (publisher) {
+    var out = {
+        '@type': 'Organization',
+        name: publisher.name,
+    };
+    if (publisher.logo) {
+        out.logo = __assign(__assign({ '@type': 'ImageObject', url: publisher.logo.url }, (publisher.logo.width && { width: publisher.logo.width })), (publisher.logo.height && { height: publisher.logo.height }));
+    }
+    return out;
+};
+var generateBookSchema = function (_a) {
+    var title = _a.title, author = _a.author, isbn = _a.isbn, numberOfPages = _a.numberOfPages, inLanguage = _a.inLanguage, publisher = _a.publisher, datePublished = _a.datePublished, image = _a.image, description = _a.description, url = _a.url, keywords = _a.keywords, bookFormat = _a.bookFormat;
+    var schema = {
+        '@context': 'https://schema.org',
+        '@type': 'Book',
+        name: title,
+        author: formatAuthor(author),
+        publisher: formatPublisher(publisher),
+    };
+    if (isbn)
+        schema.isbn = isbn;
+    if (numberOfPages)
+        schema.numberOfPages = numberOfPages;
+    if (inLanguage)
+        schema.inLanguage = inLanguage;
+    if (datePublished)
+        schema.datePublished = datePublished;
+    if (description)
+        schema.description = description;
+    if (bookFormat)
+        schema.bookFormat = bookFormat;
+    var img = formatImage(image);
+    if (img)
+        schema.image = img;
+    if (url) {
+        schema.mainEntityOfPage = {
+            '@type': 'WebPage',
+            '@id': url,
+        };
+    }
+    if (keywords && keywords.length > 0)
+        schema.keywords = keywords.join(', ');
+    return schema;
+};
+exports.generateBookSchema = generateBookSchema;

package/general/generate-breadcrumb-schema.d.ts

@@ -1,13 +1,26 @@
 /**
- * A util function to create Rich Schema for Breadcrumbs
+ * Generate a schema.org `BreadcrumbList` JSON-LD object.
  *
- * @returns formatted date - Saturday, 11/01/2020
+ * The `data` array may contain either strings or `Crumb` objects. If an
+ * entry is a string it will be treated as a path segment and slugified when
+ * appended to `baseUrl`. A `Crumb` object may provide an explicit `path` to
+ * use when building the segment, or an absolute `url` to use directly.
+ *
+ * Output: each list item will include an `item` object with `@id` (the URL)
+ * and `name` (the breadcrumb label).
+ *
+ * @param props.data - Array of path segments or Crumb objects
+ * @param props.baseUrl - The base URL to build breadcrumb URLs from
+ * @returns A JSON-LD `BreadcrumbList` object
  * @author Taimoor Khan
- * @remarks AppCorp
  */
-/** End file docs */
+interface Crumb {
+    name: string;
+    path?: string;
+    url?: string;
+}
 interface Props {
-    data: Array<string>;
+    data: Array<string | Crumb>;
     baseUrl: string;
 }
 export declare const generateBreadcrumbSchema: ({ data, baseUrl }: Props) => {
@@ -17,7 +30,10 @@ export declare const generateBreadcrumbSchema: ({ data, baseUrl }: Props) => {
         '@type': string;
         position: number;
         name: string;
-        item: string;
+        item: {
+            '@id': string;
+            name: string;
+        };
     }[];
 };
 export {};

package/general/generate-breadcrumb-schema.js

@@ -5,13 +5,24 @@ var slugify_1 = require("./slugify");
 var generateBreadcrumbSchema = function (_a) {
     var data = _a.data, baseUrl = _a.baseUrl;
     var urlItem = baseUrl;
-    var items = data.map(function (text, index) {
-        urlItem += "/".concat((0, slugify_1.slugify)(text));
+    var items = data.map(function (entry, index) {
+        var name = typeof entry === 'string' ? entry : entry.name;
+        if (typeof entry !== 'string' && entry.url) {
+            // use provided absolute url
+            urlItem = entry.url;
+        }
+        else {
+            var segment = typeof entry === 'string' ? entry : entry.path || entry.name;
+            urlItem += "/".concat((0, slugify_1.slugify)(segment));
+        }
         return {
             '@type': 'ListItem',
             position: index + 1,
-            name: text,
-            item: urlItem,
+            name: name,
+            item: {
+                '@id': urlItem,
+                name: name,
+            },
         };
     });
     return {

package/general/generate-carousel-schema.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Generate schema.org `ItemList` JSON-LD for a carousel of items.
+ *
+ * Each carousel item is emitted as a `ListItem` containing a `Thing`
+ * (Product, Article, Movie, etc.) depending on the provided item fields.
+ * Currency and availability values are normalized where applicable; use
+ * `skipInvalidCurrency` to bypass currency validation.
+ *
+ * See `CarouselSchemaOptions` and `CarouselItem` for input details.
+ * @returns A JSON-LD compatible `ItemList` object
+ */
+interface CarouselImage {
+    url: string;
+    width?: number;
+    height?: number;
+}
+interface CarouselItem {
+    id?: string;
+    name: string;
+    url?: string;
+    image?: string | CarouselImage;
+    description?: string;
+    type?: string;
+    price?: string | number;
+    priceCurrency?: string;
+    aggregateRating?: {
+        ratingValue: number | string;
+        reviewCount?: number;
+        bestRating?: number;
+        worstRating?: number;
+    };
+    offers?: Array<{
+        price: string | number;
+        priceCurrency?: string;
+        availability?: string;
+        url?: string;
+        priceValidUntil?: string;
+        priceRange?: {
+            low?: string | number;
+            high?: string | number;
+        };
+    }>;
+}
+interface CarouselSchemaOptions {
+    name?: string;
+    url?: string;
+    items: CarouselItem[];
+    skipInvalidCurrency?: boolean;
+}
+export declare const generateCarouselSchema: ({ name, url, items, skipInvalidCurrency, }: CarouselSchemaOptions) => any;
+export {};

package/general/generate-carousel-schema.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Generate schema.org `ItemList` JSON-LD for a carousel of items.
+ *
+ * Each carousel item is emitted as a `ListItem` containing a `Thing`
+ * (Product, Article, Movie, etc.) depending on the provided item fields.
+ * Currency and availability values are normalized where applicable; use
+ * `skipInvalidCurrency` to bypass currency validation.
+ *
+ * See `CarouselSchemaOptions` and `CarouselItem` for input details.
+ * @returns A JSON-LD compatible `ItemList` object
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCarouselSchema = void 0;
+var formatImage = function (image) {
+    if (!image)
+        return undefined;
+    if (typeof image === 'string')
+        return image;
+    return __assign(__assign({ '@type': 'ImageObject', url: image.url }, (image.width && { width: image.width })), (image.height && { height: image.height }));
+};
+var isValidCurrency = function (code) {
+    if (!code)
+        return false;
+    return /^[A-Z]{3}$/.test(code);
+};
+var AVAILABILITIES = [
+    'InStock',
+    'OutOfStock',
+    'PreOrder',
+    'PreSale',
+    'Discontinued',
+    'OnlineOnly',
+    'InStoreOnly',
+    'LimitedAvailability',
+    'BackOrder',
+];
+var normalizeAvailability = function (val) {
+    if (!val)
+        return undefined;
+    // accept full https://schema.org/InStock or short 'InStock'
+    try {
+        var asUrl = String(val);
+        if (asUrl.startsWith('http')) {
+            var token = asUrl.replace(/https?:\/\/schema\.org\//i, '');
+            if (AVAILABILITIES.includes(token))
+                return "https://schema.org/".concat(token);
+            return undefined;
+        }
+        if (AVAILABILITIES.includes(asUrl))
+            return "https://schema.org/".concat(asUrl);
+        return undefined;
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+var generateCarouselSchema = function (_a) {
+    var name = _a.name, url = _a.url, items = _a.items, _b = _a.skipInvalidCurrency, skipInvalidCurrency = _b === void 0 ? false : _b;
+    var itemList = items.map(function (it, index) {
+        var itemObj = {
+            '@type': it.type || 'Thing',
+            name: it.name,
+        };
+        if (it.url)
+            itemObj.url = it.url;
+        if (it.id)
+            itemObj['@id'] = it.id;
+        var img = formatImage(it.image);
+        if (img)
+            itemObj.image = img;
+        if (it.description)
+            itemObj.description = it.description;
+        // offers: support multiple offers or single price fallback
+        if (it.offers && Array.isArray(it.offers) && it.offers.length > 0) {
+            var mapped = it.offers
+                .map(function (o) {
+                if (o.priceCurrency && !isValidCurrency(o.priceCurrency)) {
+                    // either skip or throw depending on top-level option
+                    return { __invalidCurrency: o.priceCurrency };
+                }
+                var offer = {
+                    '@type': 'Offer',
+                };
+                if (o.price !== undefined)
+                    offer.price = o.price;
+                if (o.priceCurrency)
+                    offer.priceCurrency = o.priceCurrency;
+                if (o.availability) {
+                    var norm = normalizeAvailability(o.availability);
+                    if (norm)
+                        offer.availability = norm;
+                    // if invalid availability, skip the field silently
+                }
+                if (o.url)
+                    offer.url = o.url;
+                if (o.priceValidUntil)
+                    offer.priceValidUntil = o.priceValidUntil;
+                if (o.priceRange) {
+                    var pr = o.priceRange;
+                    offer.priceSpecification = __assign(__assign(__assign({ '@type': 'PriceSpecification' }, (pr.low != null && { minPrice: pr.low })), (pr.high != null && { maxPrice: pr.high })), (o.priceCurrency && { priceCurrency: o.priceCurrency }));
+                }
+                return offer;
+            })
+                .filter(function (x) { return x && !('__invalidCurrency' in x); });
+            // if any invalid currency markers were present and skipInvalidCurrency is false, throw
+            var hadInvalid = it.offers.some(function (o) { return o.priceCurrency && !isValidCurrency(o.priceCurrency); });
+            if (hadInvalid && !skipInvalidCurrency) {
+                var bad = it.offers.find(function (o) { return o.priceCurrency && !isValidCurrency(o.priceCurrency); });
+                throw new Error("Invalid currency code: ".concat(bad === null || bad === void 0 ? void 0 : bad.priceCurrency));
+            }
+            if (mapped.length > 0)
+                itemObj.offers = mapped;
+        }
+        else if (it.price !== undefined) {
+            if (it.priceCurrency && !isValidCurrency(it.priceCurrency)) {
+                if (!skipInvalidCurrency) {
+                    throw new Error("Invalid currency code: ".concat(it.priceCurrency));
+                }
+            }
+            else {
+                var offer = {
+                    '@type': 'Offer',
+                    price: it.price,
+                };
+                if (it.priceCurrency)
+                    offer.priceCurrency = it.priceCurrency;
+                itemObj.offers = offer;
+            }
+        }
+        if (it.aggregateRating) {
+            itemObj.aggregateRating = __assign(__assign(__assign({ '@type': 'AggregateRating', ratingValue: it.aggregateRating.ratingValue }, (it.aggregateRating.reviewCount != null && {
+                reviewCount: it.aggregateRating.reviewCount,
+            })), (it.aggregateRating.bestRating != null && {
+                bestRating: it.aggregateRating.bestRating,
+            })), (it.aggregateRating.worstRating != null && {
+                worstRating: it.aggregateRating.worstRating,
+            }));
+        }
+        return {
+            '@type': 'ListItem',
+            position: index + 1,
+            item: itemObj,
+        };
+    });
+    var schema = {
+        '@context': 'https://schema.org',
+        '@type': 'ItemList',
+        itemListElement: itemList,
+    };
+    if (name)
+        schema.name = name;
+    if (url) {
+        schema.mainEntityOfPage = {
+            '@type': 'WebPage',
+            '@id': url,
+        };
+    }
+    return schema;
+};
+exports.generateCarouselSchema = generateCarouselSchema;