@react-pakistan/util-functions 1.25.11 → 1.25.13

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

@@ -0,0 +1,52 @@
+/**
+ * Generate schema.org `Course` JSON-LD.
+ *
+ * Accepts metadata for a course and optional `CourseInstance` objects
+ * including offers and locations. Provider can be a string or a structured
+ * object with `logo` support. Only provided fields are emitted.
+ *
+ * See `CourseSchema` and `CourseInstance` for field details.
+ * @returns A JSON-LD compatible `Course` object
+ */
+interface CourseProvider {
+    name: string;
+    url?: string;
+    logo?: {
+        url: string;
+        width?: number;
+        height?: number;
+    };
+}
+interface CourseImage {
+    url: string;
+    width?: number;
+    height?: number;
+}
+interface CourseInstanceOffer {
+    price?: string | number;
+    priceCurrency?: string;
+    availability?: string;
+    url?: string;
+}
+interface CourseInstance {
+    name?: string;
+    description?: string;
+    courseMode?: string;
+    startDate?: string;
+    endDate?: string;
+    location?: string;
+    offers?: CourseInstanceOffer | CourseInstanceOffer[];
+}
+interface CourseSchema {
+    name: string;
+    description?: string;
+    courseCode?: string;
+    educationalCredentialAwarded?: string;
+    provider: string | CourseProvider;
+    image?: string | CourseImage | Array<string | CourseImage>;
+    url?: string;
+    hasCourseInstance?: CourseInstance | CourseInstance[];
+    keywords?: string[];
+}
+export declare const generateCourseSchema: ({ name, description, courseCode, educationalCredentialAwarded, provider, image, url, hasCourseInstance, keywords, }: CourseSchema) => any;
+export {};

package/general/generate-course-schema.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Generate schema.org `Course` JSON-LD.
+ *
+ * Accepts metadata for a course and optional `CourseInstance` objects
+ * including offers and locations. Provider can be a string or a structured
+ * object with `logo` support. Only provided fields are emitted.
+ *
+ * See `CourseSchema` and `CourseInstance` for field details.
+ * @returns A JSON-LD compatible `Course` 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.generateCourseSchema = void 0;
+var formatProvider = function (provider) {
+    if (typeof provider === 'string') {
+        return {
+            '@type': 'Organization',
+            name: provider,
+        };
+    }
+    var out = {
+        '@type': 'Organization',
+        name: provider.name,
+    };
+    if (provider.url)
+        out.url = provider.url;
+    if (provider.logo) {
+        out.logo = __assign(__assign({ '@type': 'ImageObject', url: provider.logo.url }, (provider.logo.width && { width: provider.logo.width })), (provider.logo.height && { height: provider.logo.height }));
+    }
+    return out;
+};
+var formatImage = function (img) {
+    if (!img)
+        return undefined;
+    if (typeof img === 'string')
+        return img;
+    if (Array.isArray(img)) {
+        return img.map(function (i) {
+            return typeof i === 'string'
+                ? i
+                : __assign(__assign({ '@type': 'ImageObject', url: i.url }, (i.width && { width: i.width })), (i.height && { height: i.height }));
+        });
+    }
+    return __assign(__assign({ '@type': 'ImageObject', url: img.url }, (img.width && { width: img.width })), (img.height && { height: img.height }));
+};
+var formatOffer = function (o) {
+    if (!o)
+        return undefined;
+    var mk = function (x) {
+        var out = { '@type': 'Offer' };
+        if (x.price !== undefined)
+            out.price = x.price;
+        if (x.priceCurrency)
+            out.priceCurrency = x.priceCurrency;
+        if (x.availability)
+            out.availability = x.availability;
+        if (x.url)
+            out.url = x.url;
+        return out;
+    };
+    if (Array.isArray(o))
+        return o.map(mk);
+    return mk(o);
+};
+var generateCourseSchema = function (_a) {
+    var name = _a.name, description = _a.description, courseCode = _a.courseCode, educationalCredentialAwarded = _a.educationalCredentialAwarded, provider = _a.provider, image = _a.image, url = _a.url, hasCourseInstance = _a.hasCourseInstance, keywords = _a.keywords;
+    var schema = {
+        '@context': 'https://schema.org',
+        '@type': 'Course',
+        name: name,
+    };
+    if (description)
+        schema.description = description;
+    if (courseCode)
+        schema.courseCode = courseCode;
+    if (educationalCredentialAwarded)
+        schema.educationalCredentialAwarded = educationalCredentialAwarded;
+    schema.provider = formatProvider(provider);
+    var img = formatImage(image);
+    if (img)
+        schema.image = img;
+    if (url)
+        schema.url = url;
+    if (keywords && keywords.length > 0)
+        schema.keywords = keywords.join(', ');
+    if (hasCourseInstance) {
+        var fmtInstance = function (inst) {
+            var out = { '@type': 'CourseInstance' };
+            if (inst.name)
+                out.name = inst.name;
+            if (inst.description)
+                out.description = inst.description;
+            if (inst.courseMode)
+                out.courseMode = inst.courseMode;
+            if (inst.startDate)
+                out.startDate = inst.startDate;
+            if (inst.endDate)
+                out.endDate = inst.endDate;
+            if (inst.location)
+                out.location = inst.location;
+            var offers = formatOffer(inst.offers);
+            if (offers)
+                out.offers = offers;
+            return out;
+        };
+        if (Array.isArray(hasCourseInstance))
+            schema.hasCourseInstance = hasCourseInstance.map(fmtInstance);
+        else
+            schema.hasCourseInstance = fmtInstance(hasCourseInstance);
+    }
+    return schema;
+};
+exports.generateCourseSchema = generateCourseSchema;

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

@@ -0,0 +1,64 @@
+/**
+ * Generate schema.org JSON-LD for `Dataset`, `DataCatalog`, or
+ * `DataDownload` distributions.
+ *
+ * Supports publisher formatting, distribution normalization (including
+ * encoding format validation with `skipInvalidEncoding`), variable
+ * measurement metadata and nested datasets for `DataCatalog`.
+ *
+ * See `DatasetOptions` for the input shape and available flags.
+ * @returns A JSON-LD compatible `Dataset` or `DataCatalog` object
+ */
+interface PublisherLogo {
+    url: string;
+    width?: number;
+    height?: number;
+}
+interface Publisher {
+    name: string;
+    url?: string;
+    logo?: PublisherLogo;
+}
+interface Distribution {
+    name?: string;
+    contentUrl: string;
+    encodingFormat?: string;
+    byteSize?: number | string;
+    datePublished?: string;
+    license?: string;
+    measurementTechnique?: string;
+}
+interface DatasetOptions {
+    type?: 'Dataset' | 'DataCatalog';
+    name?: string;
+    description?: string;
+    url?: string;
+    datePublished?: string;
+    dateModified?: string;
+    publisher: string | Publisher;
+    keywords?: string[];
+    license?: string;
+    version?: string;
+    variableMeasured?: string | string[] | Array<{
+        name: string;
+        value?: string | number;
+        unitText?: string;
+    }>;
+    spatialCoverage?: string;
+    distribution?: Distribution | Distribution[];
+    citation?: string | {
+        text?: string;
+        url?: string;
+    };
+    funding?: string | {
+        name: string;
+        funder?: string;
+    } | Array<string | {
+        name: string;
+        funder?: string;
+    }>;
+    skipInvalidEncoding?: boolean;
+    datasets?: DatasetOptions[];
+}
+export declare const generateDatasetSchema: ({ type, name, description, url, datePublished, dateModified, publisher, keywords, license, version, variableMeasured, spatialCoverage, distribution, datasets, skipInvalidEncoding, }: DatasetOptions) => any;
+export {};

package/general/generate-dataset-schema.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Generate schema.org JSON-LD for `Dataset`, `DataCatalog`, or
+ * `DataDownload` distributions.
+ *
+ * Supports publisher formatting, distribution normalization (including
+ * encoding format validation with `skipInvalidEncoding`), variable
+ * measurement metadata and nested datasets for `DataCatalog`.
+ *
+ * See `DatasetOptions` for the input shape and available flags.
+ * @returns A JSON-LD compatible `Dataset` or `DataCatalog` 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.generateDatasetSchema = void 0;
+var formatPublisher = function (p) {
+    if (typeof p === 'string')
+        return { '@type': 'Organization', name: p };
+    var out = { '@type': 'Organization', name: p.name };
+    if (p.url)
+        out.url = p.url;
+    if (p.logo) {
+        out.logo = { '@type': 'ImageObject', url: p.logo.url };
+        if (p.logo.width)
+            out.logo.width = p.logo.width;
+        if (p.logo.height)
+            out.logo.height = p.logo.height;
+    }
+    return out;
+};
+var formatDistribution = function (d, skipInvalidEncoding) {
+    if (skipInvalidEncoding === void 0) { skipInvalidEncoding = false; }
+    var out = {
+        '@type': 'DataDownload',
+        contentUrl: d.contentUrl,
+    };
+    if (d.name)
+        out.name = d.name;
+    if (d.encodingFormat) {
+        var enc = normalizeEncodingFormat(d.encodingFormat, skipInvalidEncoding);
+        if (enc)
+            out.encodingFormat = enc;
+    }
+    if (d.byteSize != null)
+        out.byteSize = d.byteSize;
+    if (d.datePublished)
+        out.datePublished = d.datePublished;
+    if (d.license)
+        out.license = d.license;
+    if (d.measurementTechnique)
+        out.measurementTechnique = d.measurementTechnique;
+    return out;
+};
+var ENCODING_ALIASES = {
+    csv: 'text/csv',
+    json: 'application/json',
+    geojson: 'application/geo+json',
+    xml: 'application/xml',
+    txt: 'text/plain',
+    zip: 'application/zip',
+    gzip: 'application/gzip',
+};
+var isValidMime = function (v) {
+    return /^[a-z0-9!#$&.+\-_]+\/[a-z0-9!#$&.+\-_]+$/i.test(v);
+};
+var normalizeEncodingFormat = function (val, skipInvalid) {
+    if (skipInvalid === void 0) { skipInvalid = false; }
+    if (!val)
+        return undefined;
+    var s = String(val).trim();
+    var lower = s.toLowerCase();
+    if (ENCODING_ALIASES[lower])
+        return ENCODING_ALIASES[lower];
+    if (isValidMime(s))
+        return s;
+    if (skipInvalid)
+        return undefined;
+    throw new Error("Invalid encodingFormat: ".concat(val));
+};
+var generateDatasetSchema = function (_a) {
+    var _b = _a.type, type = _b === void 0 ? 'Dataset' : _b, name = _a.name, description = _a.description, url = _a.url, datePublished = _a.datePublished, dateModified = _a.dateModified, publisher = _a.publisher, keywords = _a.keywords, license = _a.license, version = _a.version, variableMeasured = _a.variableMeasured, spatialCoverage = _a.spatialCoverage, distribution = _a.distribution, datasets = _a.datasets, 
+    // citation,
+    // funding,
+    _c = _a.skipInvalidEncoding, 
+    // citation,
+    // funding,
+    skipInvalidEncoding = _c === void 0 ? false : _c;
+    if (type === 'DataCatalog') {
+        var catalog = {
+            '@context': 'https://schema.org',
+            '@type': 'DataCatalog',
+        };
+        if (name)
+            catalog.name = name;
+        if (description)
+            catalog.description = description;
+        if (url)
+            catalog.url = url;
+        if (publisher)
+            catalog.publisher = formatPublisher(publisher);
+        if (keywords && keywords.length)
+            catalog.keywords = keywords.join(', ');
+        if (datasets && Array.isArray(datasets)) {
+            catalog.dataset = datasets.map(function (ds) {
+                var out = (0, exports.generateDatasetSchema)(__assign(__assign({}, ds), { type: 'Dataset', skipInvalidEncoding: skipInvalidEncoding }));
+                return out;
+            });
+        }
+        return catalog;
+    }
+    // default Dataset
+    var schema = {
+        '@context': 'https://schema.org',
+        '@type': 'Dataset',
+    };
+    if (name)
+        schema.name = name;
+    if (description)
+        schema.description = description;
+    if (url)
+        schema.url = url;
+    if (datePublished)
+        schema.datePublished = datePublished;
+    if (dateModified)
+        schema.dateModified = dateModified;
+    if (publisher)
+        schema.publisher = formatPublisher(publisher);
+    if (keywords && keywords.length)
+        schema.keywords = keywords.join(', ');
+    if (license)
+        schema.license = license;
+    if (version)
+        schema.version = version;
+    if (variableMeasured)
+        schema.variableMeasured = variableMeasured;
+    if (spatialCoverage)
+        schema.spatialCoverage = spatialCoverage;
+    if (distribution) {
+        var dists = Array.isArray(distribution) ? distribution : [distribution];
+        schema.distribution = dists.map(function (d) {
+            return formatDistribution(d, skipInvalidEncoding);
+        });
+    }
+    return schema;
+};
+exports.generateDatasetSchema = generateDatasetSchema;

package/general/generate-discussion-forum-schema.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Generate schema.org JSON-LD for `DiscussionForumPosting`.
+ *
+ * Formats author and publisher references, optional interaction statistics,
+ * and content fields into a compact `DiscussionForumPosting` object ready
+ * for JSON-LD embedding.
+ *
+ * See `DiscussionForumOptions` for supported inputs.
+ * @returns A JSON-LD compatible `DiscussionForumPosting` object
+ */
+interface PersonRef {
+    name?: string;
+    url?: string;
+}
+interface DiscussionForumOptions {
+    headline?: string;
+    articleBody?: string;
+    url?: string;
+    datePublished?: string;
+    dateModified?: string;
+    author?: string | PersonRef;
+    publisher?: string | {
+        name: string;
+        url?: string;
+    };
+    about?: string | {
+        '@type': string;
+        name?: string;
+    };
+    discussionUrl?: string;
+    interactionStatistic?: Array<{
+        '@type': string;
+        interactionType?: string;
+        userInteractionCount?: number;
+    }>;
+}
+export declare const generateDiscussionForumSchema: ({ headline, articleBody, url, datePublished, dateModified, author, publisher, about, discussionUrl, interactionStatistic, }?: DiscussionForumOptions) => any;
+export default generateDiscussionForumSchema;

package/general/generate-discussion-forum-schema.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Generate schema.org JSON-LD for `DiscussionForumPosting`.
+ *
+ * Formats author and publisher references, optional interaction statistics,
+ * and content fields into a compact `DiscussionForumPosting` object ready
+ * for JSON-LD embedding.
+ *
+ * See `DiscussionForumOptions` for supported inputs.
+ * @returns A JSON-LD compatible `DiscussionForumPosting` object
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDiscussionForumSchema = 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 generateDiscussionForumSchema = function (_a) {
+    var _b = _a === void 0 ? {} : _a, headline = _b.headline, articleBody = _b.articleBody, url = _b.url, datePublished = _b.datePublished, dateModified = _b.dateModified, author = _b.author, publisher = _b.publisher, about = _b.about, discussionUrl = _b.discussionUrl, interactionStatistic = _b.interactionStatistic;
+    var schema = {
+        '@context': 'https://schema.org',
+        '@type': 'DiscussionForumPosting',
+    };
+    if (headline)
+        schema.headline = headline;
+    if (articleBody)
+        schema.articleBody = articleBody;
+    if (url)
+        schema.url = url;
+    if (datePublished)
+        schema.datePublished = datePublished;
+    if (dateModified)
+        schema.dateModified = dateModified;
+    var a = formatPerson(author);
+    if (a)
+        schema.author = a;
+    var pub = formatPublisher(publisher);
+    if (pub)
+        schema.publisher = pub;
+    if (about)
+        schema.about = about;
+    if (discussionUrl)
+        schema.discussionUrl = discussionUrl;
+    if (interactionStatistic && Array.isArray(interactionStatistic))
+        schema.interactionStatistic = interactionStatistic;
+    return schema;
+};
+exports.generateDiscussionForumSchema = generateDiscussionForumSchema;
+exports.default = exports.generateDiscussionForumSchema;

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

@@ -0,0 +1,67 @@
+/**
+ * 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
+ */
+interface PersonRef {
+    name?: string;
+    url?: string;
+}
+interface PublisherRef {
+    name: string;
+    url?: string;
+}
+interface Answer {
+    text: string;
+    url?: string;
+    author?: string | PersonRef;
+    upvoteCount?: number;
+    feedback?: string | {
+        text?: string;
+        score?: number;
+    };
+}
+interface Question {
+    name?: string;
+    text?: string;
+    acceptedAnswer?: Answer | Answer[];
+    suggestedAnswer?: Answer | Answer[];
+    answerCount?: number;
+    upvoteCount?: number;
+    difficulty?: string;
+    points?: number;
+    score?: number;
+    timeLimit?: string;
+    attempts?: number;
+    tags?: string[];
+    hints?: string[];
+    learningObjective?: string | string[];
+    timeRecommended?: string;
+    isRequired?: boolean;
+}
+interface QuizOptions {
+    name?: string;
+    description?: string;
+    url?: string;
+    datePublished?: string;
+    author?: string | PersonRef;
+    publisher?: string | PublisherRef;
+    difficulty?: string;
+    learningResourceType?: string;
+    educationalLevel?: string;
+    timeRequired?: string;
+    typicalAgeRange?: string | number;
+    inLanguage?: string;
+    keywords?: string[];
+    learningOutcome?: string | string[];
+    isAccessibleForFree?: boolean;
+    questions?: Question[];
+}
+export declare const generateEducationSchema: ({ name, description, url, datePublished, author, publisher, difficulty, learningResourceType, educationalLevel, timeRequired, typicalAgeRange, inLanguage, keywords, learningOutcome, isAccessibleForFree, questions, }?: QuizOptions) => any;
+export default generateEducationSchema;