semantic-analysis/lib/structured-data/validation/schema/SchemaProvider.js

Extensible semantic Structured Data analysis library for Microdata and JSON-LD

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SchemaProvider = void 0;
var tslib_1 = require("tslib");
var schema_json_1 = tslib_1.__importDefault(require("./schema.json"));
var TermLoader_1 = require("./TermLoader");
var util_1 = require("./util");
var SchemaProvider = /** @class */ (function () {
    function SchemaProvider() {
        /* Properties */
        var _this = this;
        this.cache = new Map();
        /* Helpers */
        this.createTerm = function (data) { return ({
            /* General */
            id: data['@id'],
            type: _this.parseTypes(data['@type']),
            label: data['rdfs:label'],
            comment: data['rdfs:comment'],
            supersededBy: _this.parseIDs(data['http://schema.org/supersededBy']),
            /* Class */
            subClassOf: _this.parseIDs(data['rdfs:subClassOf']),
            /* Property */
            rangeIncludes: _this.parseIDs(data['http://schema.org/rangeIncludes']),
            domainIncludes: _this.parseIDs(data['http://schema.org/domainIncludes']),
        }); };
        this.parseIDs = function (data) {
            return data
                ? (Array.isArray(data) ? data : [data])
                    .filter(function (t) { return typeof t['@id'] === 'string'; })
                    .map(function (t) { return new TermLoader_1.TermLoader(t['@id'], _this); })
                : undefined;
        };
        this.parseTypes = function (type) {
            return type
                ? (Array.isArray(type) ? type : [type])
                    .map(function (t) {
                    switch (t) {
                        case 'rdfs:Class': return 'Class';
                        case 'rdf:Property': return 'Property';
                        default: return new TermLoader_1.TermLoader(t, _this);
                    }
                })
                    .filter(function (t) { return t; })
                : undefined;
        };
    }
    /* Schema */
    SchemaProvider.prototype.get = function (id) {
        if (this.cache.has(id)) {
            return this.cache.get(id);
        }
        var data = schema_json_1.default['@graph'].find(function (t) { return t['@id'] === id; });
        var term = data ? this.createTerm(data) : undefined;
        this.cache.set(id, term);
        return term;
    };
    SchemaProvider.prototype.getProperties = function () {
        var _this = this;
        var classes = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            classes[_i] = arguments[_i];
        }
        classes.forEach(function (c) {
            if (!util_1.isClass(c)) {
                throw new TypeError('Given term is not of class type');
            }
        });
        var stack = classes.slice();
        var search = new Set();
        while (stack.length) {
            var c = stack.shift();
            search.add(c.id);
            stack.unshift.apply(stack, c.subClassOf || []);
        }
        return schema_json_1.default['@graph']
            .filter(function (term) {
            var domain = term['http://schema.org/domainIncludes'];
            return domain &&
                (Array.isArray(domain) ? domain : [domain])
                    .filter(function (d) { return search.has(d['@id']); })
                    .length;
        })
            .map(function (term) { return _this.get(term['@id']); });
    };
    return SchemaProvider;
}());
exports.SchemaProvider = SchemaProvider;
//# sourceMappingURL=SchemaProvider.js.map