@react-pakistan/util-functions 1.25.11 → 1.25.13

package/general/generate-education-schema.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Generate schema.org JSON-LD for a Quiz (Question and Answer items).
+ *
+ * Supports author and publisher metadata along with detailed `Question`
+ * and `Answer` structures (including accepted/suggested answers,
+ * feedback and scoring fields). Only provided values are emitted.
+ *
+ * See `QuizOptions`, `Question`, and `Answer` types for the available
+ * fields and formats.
+ * @returns A JSON-LD compatible `Quiz` object
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEducationSchema = void 0;
+var formatPerson = function (p) {
+    if (!p)
+        return undefined;
+    if (typeof p === 'string')
+        return { '@type': 'Person', name: p };
+    var out = { '@type': 'Person' };
+    if (p.name)
+        out.name = p.name;
+    if (p.url)
+        out.url = p.url;
+    return out;
+};
+var formatPublisher = function (p) {
+    if (!p)
+        return undefined;
+    if (typeof p === 'string')
+        return { '@type': 'Organization', name: p };
+    var out = { '@type': 'Organization', name: p.name };
+    if (p.url)
+        out.url = p.url;
+    return out;
+};
+var formatAnswer = function (a) {
+    var out = { '@type': 'Answer', text: a.text };
+    if (a.url)
+        out.url = a.url;
+    if (a.author)
+        out.author = formatPerson(a.author);
+    if (a.upvoteCount != null)
+        out.upvoteCount = a.upvoteCount;
+    if (a.feedback)
+        out.feedback = a.feedback;
+    return out;
+};
+var formatQuestion = function (q) {
+    var out = { '@type': 'Question' };
+    if (q.name)
+        out.name = q.name;
+    if (q.text)
+        out.text = q.text;
+    if (q.answerCount != null)
+        out.answerCount = q.answerCount;
+    if (q.upvoteCount != null)
+        out.upvoteCount = q.upvoteCount;
+    if (q.difficulty)
+        out.difficulty = q.difficulty;
+    if (q.points != null)
+        out.points = q.points;
+    if (q.score != null)
+        out.score = q.score;
+    if (q.timeLimit)
+        out.timeLimit = q.timeLimit;
+    if (q.attempts != null)
+        out.attempts = q.attempts;
+    if (q.tags && Array.isArray(q.tags))
+        out.tags = q.tags;
+    if (q.hints && Array.isArray(q.hints))
+        out.hints = q.hints;
+    if (q.learningObjective)
+        out.learningObjective = q.learningObjective;
+    if (q.timeRecommended)
+        out.timeRecommended = q.timeRecommended;
+    if (q.isRequired != null)
+        out.isRequired = q.isRequired;
+    if (q.acceptedAnswer) {
+        var a = Array.isArray(q.acceptedAnswer)
+            ? q.acceptedAnswer.map(formatAnswer)
+            : formatAnswer(q.acceptedAnswer);
+        out.acceptedAnswer = a;
+    }
+    if (q.suggestedAnswer) {
+        var s = Array.isArray(q.suggestedAnswer)
+            ? q.suggestedAnswer.map(formatAnswer)
+            : formatAnswer(q.suggestedAnswer);
+        out.suggestedAnswer = s;
+    }
+    return out;
+};
+var generateEducationSchema = function (_a) {
+    var _b = _a === void 0 ? {} : _a, name = _b.name, description = _b.description, url = _b.url, datePublished = _b.datePublished, author = _b.author, publisher = _b.publisher, difficulty = _b.difficulty, learningResourceType = _b.learningResourceType, educationalLevel = _b.educationalLevel, timeRequired = _b.timeRequired, typicalAgeRange = _b.typicalAgeRange, inLanguage = _b.inLanguage, keywords = _b.keywords, learningOutcome = _b.learningOutcome, isAccessibleForFree = _b.isAccessibleForFree, questions = _b.questions;
+    var schema = {
+        '@context': 'https://schema.org',
+        '@type': 'Quiz',
+    };
+    if (name)
+        schema.name = name;
+    if (description)
+        schema.description = description;
+    if (url)
+        schema.url = url;
+    if (datePublished)
+        schema.datePublished = datePublished;
+    var a = formatPerson(author);
+    if (a)
+        schema.author = a;
+    var p = formatPublisher(publisher);
+    if (p)
+        schema.publisher = p;
+    if (difficulty)
+        schema.difficulty = difficulty;
+    if (learningResourceType)
+        schema.learningResourceType = learningResourceType;
+    if (educationalLevel)
+        schema.educationalLevel = educationalLevel;
+    if (timeRequired)
+        schema.timeRequired = timeRequired;
+    if (typicalAgeRange != null)
+        schema.typicalAgeRange = typicalAgeRange;
+    if (inLanguage)
+        schema.inLanguage = inLanguage;
+    if (keywords && Array.isArray(keywords))
+        schema.keywords = keywords.join(', ');
+    if (learningOutcome)
+        schema.learningOutcome = learningOutcome;
+    if (isAccessibleForFree != null)
+        schema.isAccessibleForFree = isAccessibleForFree;
+    if (questions && Array.isArray(questions)) {
+        schema.question = questions.map(formatQuestion);
+    }
+    return schema;
+};
+exports.generateEducationSchema = generateEducationSchema;
+exports.default = exports.generateEducationSchema;

package/general/generate-employer-aggregate-rating-schema.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Generate schema.org JSON-LD for `EmployerAggregateRating` and the
+ * hosting `Organization`.
+ *
+ * The helper builds an `EmployerAggregateRating` object and nests it
+ * inside an `Organization` representation of the employer. Use the
+ * `EmployerAggregateOptions` interface for inputs.
+ * @returns A JSON-LD compatible `Organization` object with
+ * `aggregateRating` included
+ */
+interface OrgRef {
+    name: string;
+    url?: string;
+    sameAs?: string;
+}
+interface EmployerAggregateOptions {
+    employer: string | OrgRef;
+    ratingValue?: number;
+    ratingCount?: number;
+    reviewCount?: number;
+    bestRating?: number;
+    worstRating?: number;
+    url?: string;
+    description?: string;
+    datePublished?: string;
+}
+export declare const generateEmployerAggregateRatingSchema: ({ employer, ratingValue, ratingCount, reviewCount, bestRating, worstRating, url, description, datePublished, }: EmployerAggregateOptions) => any;
+export default generateEmployerAggregateRatingSchema;

package/general/generate-employer-aggregate-rating-schema.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Generate schema.org JSON-LD for `EmployerAggregateRating` and the
+ * hosting `Organization`.
+ *
+ * The helper builds an `EmployerAggregateRating` object and nests it
+ * inside an `Organization` representation of the employer. Use the
+ * `EmployerAggregateOptions` interface for inputs.
+ * @returns A JSON-LD compatible `Organization` object with
+ * `aggregateRating` included
+ */
+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.generateEmployerAggregateRatingSchema = void 0;
+var formatOrganization = function (o) {
+    if (typeof o === 'string')
+        return { '@type': 'Organization', name: o };
+    var out = { '@type': 'Organization', name: o.name };
+    if (o.url)
+        out.url = o.url;
+    if (o.sameAs)
+        out.sameAs = o.sameAs;
+    return out;
+};
+var generateEmployerAggregateRatingSchema = function (_a) {
+    var employer = _a.employer, ratingValue = _a.ratingValue, ratingCount = _a.ratingCount, reviewCount = _a.reviewCount, bestRating = _a.bestRating, worstRating = _a.worstRating, url = _a.url, description = _a.description, datePublished = _a.datePublished;
+    // Build the EmployerAggregateRating object
+    var rating = {
+        '@type': 'EmployerAggregateRating',
+    };
+    if (ratingValue != null)
+        rating.ratingValue = ratingValue;
+    if (ratingCount != null)
+        rating.ratingCount = ratingCount;
+    if (reviewCount != null)
+        rating.reviewCount = reviewCount;
+    if (bestRating != null)
+        rating.bestRating = bestRating;
+    if (worstRating != null)
+        rating.worstRating = worstRating;
+    if (url)
+        rating.url = url;
+    if (description)
+        rating.description = description;
+    if (datePublished)
+        rating.datePublished = datePublished;
+    // Return the Organization with aggregateRating nested
+    var org = formatOrganization(employer);
+    var schema = __assign({ '@context': 'https://schema.org', '@type': 'Organization' }, org);
+    schema.aggregateRating = rating;
+    return schema;
+};
+exports.generateEmployerAggregateRatingSchema = generateEmployerAggregateRatingSchema;
+exports.default = exports.generateEmployerAggregateRatingSchema;

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

@@ -0,0 +1,62 @@
+/**
+ * Generate schema.org `Event` JSON-LD.
+ *
+ * Supports `Place` and `VirtualLocation` types for `location`, optional
+ * `offers`, performers, organizer, and availability/status normalization.
+ * Currency values are validated with `skipInvalidCurrency` when present.
+ *
+ * See `EventSchemaOptions` below for the complete input shape.
+ * @returns A JSON-LD compatible `Event` object
+ */
+interface EventImage {
+    url: string;
+    width?: number;
+    height?: number;
+}
+interface EventLocationAddress {
+    streetAddress?: string;
+    addressLocality?: string;
+    postalCode?: string;
+    addressRegion?: string;
+    addressCountry?: string;
+}
+interface EventLocation {
+    type?: 'Place' | 'VirtualLocation';
+    name?: string;
+    url?: string;
+    address?: string | EventLocationAddress;
+}
+interface EventOrganizer {
+    name: string;
+    url?: string;
+}
+interface EventPerformer {
+    name: string;
+    url?: string;
+    type?: 'Person' | 'Organization';
+}
+interface EventOffer {
+    price?: string | number;
+    priceCurrency?: string;
+    availability?: string;
+    url?: string;
+    priceValidUntil?: string;
+}
+interface EventSchemaOptions {
+    name: string;
+    startDate: string;
+    endDate?: string;
+    description?: string;
+    location?: string | EventLocation;
+    url?: string;
+    image?: string | EventImage;
+    organizer?: string | EventOrganizer;
+    performers?: string | EventPerformer | Array<string | EventPerformer>;
+    offers?: EventOffer | EventOffer[];
+    isAccessibleForFree?: boolean;
+    eventStatus?: string;
+    eventAttendanceMode?: string;
+    skipInvalidCurrency?: boolean;
+}
+export declare const generateEventSchema: ({ name, startDate, endDate, description, location, url, image, organizer, performers, offers, isAccessibleForFree, eventStatus, eventAttendanceMode, skipInvalidCurrency, }: EventSchemaOptions) => any;
+export {};

package/general/generate-event-schema.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * Generate schema.org `Event` JSON-LD.
+ *
+ * Supports `Place` and `VirtualLocation` types for `location`, optional
+ * `offers`, performers, organizer, and availability/status normalization.
+ * Currency values are validated with `skipInvalidCurrency` when present.
+ *
+ * See `EventSchemaOptions` below for the complete input shape.
+ * @returns A JSON-LD compatible `Event` 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.generateEventSchema = 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;
+    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 normalizeStatusOrMode = function (val) {
+    if (!val)
+        return undefined;
+    if (val.startsWith('http'))
+        return val;
+    return "https://schema.org/".concat(val);
+};
+var formatLocation = function (loc) {
+    if (!loc)
+        return undefined;
+    if (typeof loc === 'string')
+        return loc;
+    if (loc.type === 'VirtualLocation') {
+        var out = { '@type': 'VirtualLocation' };
+        if (loc.url)
+            out.url = loc.url;
+        if (loc.name)
+            out.name = loc.name;
+        return out;
+    }
+    var place = { '@type': 'Place' };
+    if (loc.name)
+        place.name = loc.name;
+    if (loc.url)
+        place.url = loc.url;
+    if (loc.address) {
+        if (typeof loc.address === 'string') {
+            place.address = loc.address;
+        }
+        else {
+            place.address = __assign(__assign(__assign(__assign(__assign({ '@type': 'PostalAddress' }, (loc.address.streetAddress && {
+                streetAddress: loc.address.streetAddress,
+            })), (loc.address.addressLocality && {
+                addressLocality: loc.address.addressLocality,
+            })), (loc.address.postalCode && { postalCode: loc.address.postalCode })), (loc.address.addressRegion && {
+                addressRegion: loc.address.addressRegion,
+            })), (loc.address.addressCountry && {
+                addressCountry: loc.address.addressCountry,
+            }));
+        }
+    }
+    return place;
+};
+var formatOrganizer = function (org) {
+    if (!org)
+        return undefined;
+    if (typeof org === 'string') {
+        return {
+            '@type': 'Organization',
+            name: org,
+        };
+    }
+    return __assign({ '@type': 'Organization', name: org.name }, (org.url && { url: org.url }));
+};
+var formatPerformer = function (p) {
+    if (typeof p === 'string') {
+        return {
+            '@type': 'Person',
+            name: p,
+        };
+    }
+    return __assign({ '@type': p.type || 'Person', name: p.name }, (p.url && { url: p.url }));
+};
+var generateEventSchema = function (_a) {
+    var name = _a.name, startDate = _a.startDate, endDate = _a.endDate, description = _a.description, location = _a.location, url = _a.url, image = _a.image, organizer = _a.organizer, performers = _a.performers, offers = _a.offers, isAccessibleForFree = _a.isAccessibleForFree, eventStatus = _a.eventStatus, eventAttendanceMode = _a.eventAttendanceMode, _b = _a.skipInvalidCurrency, skipInvalidCurrency = _b === void 0 ? false : _b;
+    var schema = {
+        '@context': 'https://schema.org',
+        '@type': 'Event',
+        name: name,
+        startDate: startDate,
+    };
+    if (endDate)
+        schema.endDate = endDate;
+    if (description)
+        schema.description = description;
+    var img = formatImage(image);
+    if (img)
+        schema.image = img;
+    var loc = formatLocation(location);
+    if (loc)
+        schema.location = loc;
+    if (url) {
+        schema.mainEntityOfPage = {
+            '@type': 'WebPage',
+            '@id': url,
+        };
+    }
+    var org = formatOrganizer(organizer);
+    if (org)
+        schema.organizer = org;
+    if (performers) {
+        if (Array.isArray(performers)) {
+            schema.performer = performers.map(function (p) { return formatPerformer(p); });
+        }
+        else {
+            schema.performer = formatPerformer(performers);
+        }
+    }
+    if (typeof isAccessibleForFree === 'boolean')
+        schema.isAccessibleForFree = isAccessibleForFree;
+    if (eventStatus) {
+        var norm = normalizeStatusOrMode(eventStatus);
+        if (norm)
+            schema.eventStatus = norm;
+    }
+    if (eventAttendanceMode) {
+        var norm = normalizeStatusOrMode(eventAttendanceMode);
+        if (norm)
+            schema.eventAttendanceMode = norm;
+    }
+    // offers handling (single or array)
+    if (offers) {
+        var promises = Array.isArray(offers) ? offers : [offers];
+        var mapped = promises
+            .map(function (o) {
+            if (o.priceCurrency && !isValidCurrency(o.priceCurrency)) {
+                return { __invalidCurrency: o.priceCurrency };
+            }
+            var off = { '@type': 'Offer' };
+            if (o.price != null)
+                off.price = o.price;
+            if (o.priceCurrency)
+                off.priceCurrency = o.priceCurrency;
+            if (o.url)
+                off.url = o.url;
+            if (o.priceValidUntil)
+                off.priceValidUntil = o.priceValidUntil;
+            if (o.availability) {
+                var n = normalizeAvailability(o.availability);
+                if (n)
+                    off.availability = n;
+            }
+            return off;
+        })
+            .filter(function (x) { return x && !('__invalidCurrency' in x); });
+        var hadInvalid = promises.some(function (o) { return o.priceCurrency && !isValidCurrency(o.priceCurrency); });
+        if (hadInvalid && !skipInvalidCurrency) {
+            var bad = promises.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 === 1)
+            schema.offers = mapped[0];
+        else if (mapped.length > 1)
+            schema.offers = mapped;
+    }
+    return schema;
+};
+exports.generateEventSchema = generateEventSchema;

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

@@ -1,18 +1,22 @@
 /**
- * A util function to create Rich Schema for FAQ
+ * Generate a schema.org `FAQPage` JSON-LD object.
  *
- * @returns formatted date - Saturday, 11/01/2020
- * @author Taimoor Khan
- * @remarks AppCorp
+ * Each FAQ item becomes a `Question` with an `acceptedAnswer` of type
+ * `Answer`. Plain-text answers are wrapped in a single paragraph tag.
+ * If the provided answer already contains HTML tags it will be preserved
+ * as-is to avoid double-wrapping.
+ *
+ * @param props.data - Array of FAQ items with `question` and `answer`
+ * @returns A JSON-LD `FAQPage` object
  */
-/** End file docs */
-interface FAQ {
-    data: Array<{
-        answer: string;
-        question: string;
-    }>;
+interface FAQItem {
+    question: string;
+    answer: string;
+}
+interface FAQProps {
+    data: FAQItem[];
 }
-export declare const generateFAQSchema: ({ data }: FAQ) => {
+export declare const generateFAQSchema: ({ data }: FAQProps) => {
     '@context': string;
     '@type': string;
     mainEntity: {

package/general/generate-faq-schema.js

@@ -1,14 +1,26 @@
 "use strict";
 /**
- * A util function to create Rich Schema for FAQ
+ * Generate a schema.org `FAQPage` JSON-LD object.
  *
- * @returns formatted date - Saturday, 11/01/2020
- * @author Taimoor Khan
- * @remarks AppCorp
+ * Each FAQ item becomes a `Question` with an `acceptedAnswer` of type
+ * `Answer`. Plain-text answers are wrapped in a single paragraph tag.
+ * If the provided answer already contains HTML tags it will be preserved
+ * as-is to avoid double-wrapping.
+ *
+ * @param props.data - Array of FAQ items with `question` and `answer`
+ * @returns A JSON-LD `FAQPage` object
  */
-/** End file docs */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateFAQSchema = void 0;
+var wrapAnswer = function (text) {
+    if (!text)
+        return text;
+    var trimmed = text.trim();
+    // naive HTML detection: if it contains a tag, assume it's HTML
+    if (trimmed.startsWith('<') && trimmed.includes('>'))
+        return text;
+    return "<p>".concat(text, "</p>");
+};
 var generateFAQSchema = function (_a) {
     var data = _a.data;
     var items = data.map(function (_a) {
@@ -18,7 +30,7 @@ var generateFAQSchema = function (_a) {
             name: question,
             acceptedAnswer: {
                 '@type': 'Answer',
-                text: "<p>".concat(answer, "</p>"),
+                text: wrapAnswer(answer),
             },
         };
     });

package/general/generate-image-metadata-schema.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Generate schema.org `ImageObject` JSON-LD for image metadata.
+ *
+ * Accepts author/copyright holders, thumbnail, licenses and descriptive
+ * metadata and formats them into an `ImageObject` suitable for JSON-LD
+ * embedding. Only provided fields are emitted.
+ *
+ * See `ImageMetadataOptions` for the exact accepted fields.
+ * @returns A JSON-LD compatible `ImageObject`
+ */
+interface SimplePerson {
+    name: string;
+    url?: string;
+}
+interface ImageThumbnail {
+    url: string;
+    width?: number;
+    height?: number;
+}
+interface ImageMetadataOptions {
+    name?: string;
+    contentUrl: string;
+    description?: string;
+    caption?: string;
+    uploadDate?: string;
+    author?: string | SimplePerson;
+    copyrightHolder?: string | SimplePerson;
+    license?: string;
+    encodingFormat?: string;
+    contentSize?: string;
+    thumbnail?: string | ImageThumbnail;
+    keywords?: string[];
+}
+export declare const generateImageMetadataSchema: ({ name, contentUrl, description, caption, uploadDate, author, copyrightHolder, license, encodingFormat, contentSize, thumbnail, keywords, }: ImageMetadataOptions) => any;
+export {};

package/general/generate-image-metadata-schema.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Generate schema.org `ImageObject` JSON-LD for image metadata.
+ *
+ * Accepts author/copyright holders, thumbnail, licenses and descriptive
+ * metadata and formats them into an `ImageObject` suitable for JSON-LD
+ * embedding. Only provided fields are emitted.
+ *
+ * See `ImageMetadataOptions` for the exact accepted fields.
+ * @returns A JSON-LD compatible `ImageObject`
+ */
+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.generateImageMetadataSchema = void 0;
+var formatPerson = function (p) {
+    if (!p)
+        return undefined;
+    if (typeof p === 'string')
+        return { '@type': 'Person', name: p };
+    return __assign({ '@type': 'Person', name: p.name }, (p.url && { url: p.url }));
+};
+var formatThumbnail = function (t) {
+    if (!t)
+        return undefined;
+    if (typeof t === 'string')
+        return t;
+    return __assign(__assign({ '@type': 'ImageObject', url: t.url }, (t.width && { width: t.width })), (t.height && { height: t.height }));
+};
+var generateImageMetadataSchema = function (_a) {
+    var name = _a.name, contentUrl = _a.contentUrl, description = _a.description, caption = _a.caption, uploadDate = _a.uploadDate, author = _a.author, copyrightHolder = _a.copyrightHolder, license = _a.license, encodingFormat = _a.encodingFormat, contentSize = _a.contentSize, thumbnail = _a.thumbnail, keywords = _a.keywords;
+    var schema = {
+        '@context': 'https://schema.org',
+        '@type': 'ImageObject',
+        contentUrl: contentUrl,
+    };
+    if (name)
+        schema.name = name;
+    if (description)
+        schema.description = description;
+    if (caption)
+        schema.caption = caption;
+    if (uploadDate)
+        schema.uploadDate = uploadDate;
+    var a = formatPerson(author);
+    if (a)
+        schema.author = a;
+    var ch = formatPerson(copyrightHolder);
+    if (ch)
+        schema.copyrightHolder = ch;
+    if (license)
+        schema.license = license;
+    if (encodingFormat)
+        schema.encodingFormat = encodingFormat;
+    if (contentSize)
+        schema.contentSize = contentSize;
+    var thumb = formatThumbnail(thumbnail);
+    if (thumb)
+        schema.thumbnail = thumb;
+    if (keywords && keywords.length > 0)
+        schema.keywords = keywords.join(', ');
+    return schema;
+};
+exports.generateImageMetadataSchema = generateImageMetadataSchema;