@natlibfi/ekirjasto-opds-feed-parser 1.0.0 → 2.0.1-post.1

package/README.md

@@ -9,7 +9,7 @@ Covers [OPDS 1.1 version](http://opds-spec.org/specs/opds-catalog-1-1-20110627/)
 ## Usage
 
 ```sh
-npm install ekirjasto-opds-feed-parser
+npm install @natlibfi/ekirjasto-opds-feed-parser
 ```
 
 Example:

package/lib/src/accessibility.d.ts

@@ -0,0 +1,12 @@
+import Conformance from "./conformance";
+import WaysOfReading from "./ways_of_reading";
+export default class Accessibility {
+    conformance?: Conformance;
+    waysOfReading?: WaysOfReading;
+    constructor(args?: {
+        conformance?: Conformance;
+        waysOfReading?: WaysOfReading;
+    });
+}
+export interface AccessibilityArgs extends Accessibility {
+}

package/lib/src/accessibility.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Define the Accessibility class
+var Accessibility = /** @class */ (function () {
+    // This constructor is used when
+    // we are initializing a new Accessibility object
+    // with the given parameters
+    function Accessibility(args) {
+        if (args) {
+            this.conformance = args.conformance;
+            this.waysOfReading = args.waysOfReading;
+        }
+    }
+    return Accessibility;
+}());
+exports.default = Accessibility;

package/lib/src/accessibility_parser.d.ts

@@ -0,0 +1,8 @@
+import Accessibility from "./accessibility";
+import Xml2jsOutputParser from "./xml2js_output_parser";
+export default class AccessibilityParser extends Xml2jsOutputParser<Accessibility> {
+    parse(tag: any): Accessibility;
+    private parseConformance;
+    private parseWaysOfReading;
+    private createAccessibility;
+}

package/lib/src/accessibility_parser.js

@@ -0,0 +1,71 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var accessibility_1 = require("./accessibility");
+var conformance_parser_1 = require("./conformance_parser");
+var ways_of_reading_parser_1 = require("./ways_of_reading_parser");
+var xml2js_output_parser_1 = require("./xml2js_output_parser");
+// AccessibilityParser class extends Xml2jsOutputParser
+// to handle parsing of accessibility data
+var AccessibilityParser = /** @class */ (function (_super) {
+    __extends(AccessibilityParser, _super);
+    function AccessibilityParser() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    // function parse is given a tag as parameter
+    // (it should be the XML element <accessibility>)
+    // and extracts accessibility details from it.
+    AccessibilityParser.prototype.parse = function (tag) {
+        var conformance = this.parseConformance(tag);
+        var waysOfReading = this.parseWaysOfReading(tag);
+        return this.createAccessibility(conformance, waysOfReading);
+    };
+    // helper function to parse the 'conformance' subtag
+    AccessibilityParser.prototype.parseConformance = function (tag) {
+        // first create instance of the ConformanceParser
+        // and define the subtag's name from <conformance>
+        var subtagName = "conformance";
+        var subtagParser = new conformance_parser_1.default(this.prefixes);
+        // then extract conformance metadata from XML using the parser
+        return this.parseSubtag(tag, subtagName, subtagParser);
+    };
+    // helper function to parse the 'waysOfReading' subtag
+    AccessibilityParser.prototype.parseWaysOfReading = function (tag) {
+        // first create a instance of the WaysOfReadingParser
+        // and define the subtag's name from <waysOfReading>
+        var subtagName = "waysOfReading";
+        var subtagParser = new ways_of_reading_parser_1.default(this.prefixes);
+        // then extract ways of reading metadata from XML using the parser
+        return this.parseSubtag(tag, subtagName, subtagParser);
+    };
+    // helper function that creates an Accessibility instance
+    // from the parsed data given as parameter
+    AccessibilityParser.prototype.createAccessibility = function (conformance, waysOfReading) {
+        // create an AccessibilityArgs object
+        // that holds the extracted data
+        var accessibilityArgs = {
+            conformance: conformance,
+            waysOfReading: waysOfReading,
+        };
+        // return a new Accessibility instance
+        // that is created using accessibilityArgs
+        // (there's a constructor init method for this)
+        return new accessibility_1.default(accessibilityArgs);
+    };
+    return AccessibilityParser;
+}(xml2js_output_parser_1.default));
+exports.default = AccessibilityParser;

package/lib/src/acquisition_feed.d.ts

@@ -0,0 +1,3 @@
+import OPDSFeed from "./opds_feed";
+export default class AcquisitionFeed extends OPDSFeed {
+}

package/lib/src/acquisition_feed.js

@@ -0,0 +1,26 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var opds_feed_1 = require("./opds_feed");
+var AcquisitionFeed = /** @class */ (function (_super) {
+    __extends(AcquisitionFeed, _super);
+    function AcquisitionFeed() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return AcquisitionFeed;
+}(opds_feed_1.default));
+exports.default = AcquisitionFeed;

package/lib/src/alternate_link.d.ts

@@ -0,0 +1,5 @@
+import OPDSLink, { OPDSLinkArgs } from "./opds_link";
+export default class AlternateLink extends OPDSLink {
+    static REL: string;
+    constructor(args: OPDSLinkArgs);
+}

package/lib/src/alternate_link.js

@@ -0,0 +1,30 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var opds_link_1 = require("./opds_link");
+var AlternateLink = /** @class */ (function (_super) {
+    __extends(AlternateLink, _super);
+    function AlternateLink(args) {
+        var _this = this;
+        args.rel = AlternateLink.REL;
+        _this = _super.call(this, args) || this;
+        return _this;
+    }
+    AlternateLink.REL = "alternate";
+    return AlternateLink;
+}(opds_link_1.default));
+exports.default = AlternateLink;

package/lib/src/availability_parser.d.ts

@@ -0,0 +1,5 @@
+import OPDSAvailability from "./opds_availability";
+import Xml2jsOutputParser from "./xml2js_output_parser";
+export default class AvailabilityParser extends Xml2jsOutputParser<OPDSAvailability> {
+    parse(element: any): OPDSAvailability;
+}

package/lib/src/availability_parser.js

@@ -0,0 +1,34 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var xml2js_output_parser_1 = require("./xml2js_output_parser");
+var AvailabilityParser = /** @class */ (function (_super) {
+    __extends(AvailabilityParser, _super);
+    function AvailabilityParser() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AvailabilityParser.prototype.parse = function (element) {
+        var parsed = {
+            status: this.parseAttribute(element, "status"),
+            since: this.parseAttribute(element, "since"),
+            until: this.parseAttribute(element, "until")
+        };
+        return parsed;
+    };
+    return AvailabilityParser;
+}(xml2js_output_parser_1.default));
+exports.default = AvailabilityParser;

package/lib/src/category.d.ts

@@ -0,0 +1,8 @@
+export default class Category {
+    term: string;
+    scheme: string;
+    label: string;
+    constructor(args: CategoryArgs);
+}
+export interface CategoryArgs extends Category {
+}

package/lib/src/category.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Category = /** @class */ (function () {
+    function Category(args) {
+        Object.assign(this, args);
+    }
+    return Category;
+}());
+exports.default = Category;

package/lib/src/category_parser.d.ts

@@ -0,0 +1,5 @@
+import Category from "./category";
+import Xml2jsOutputParser from "./xml2js_output_parser";
+export default class CategoryParser extends Xml2jsOutputParser<Category> {
+    parse(category: any): Category;
+}

package/lib/src/category_parser.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var category_1 = require("./category");
+var xml2js_output_parser_1 = require("./xml2js_output_parser");
+var CategoryParser = /** @class */ (function (_super) {
+    __extends(CategoryParser, _super);
+    function CategoryParser() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CategoryParser.prototype.parse = function (category) {
+        var term = this.parseAttribute(category, "term");
+        var scheme = this.parseAttribute(category, "scheme");
+        var label = this.parseAttribute(category, "label");
+        return new category_1.default({ term: term, scheme: scheme, label: label });
+    };
+    return CategoryParser;
+}(xml2js_output_parser_1.default));
+exports.default = CategoryParser;

package/lib/src/complete_entry_link.d.ts

@@ -0,0 +1,6 @@
+import AlternateLink from "./alternate_link";
+import { OPDSLinkArgs } from "./opds_link";
+export default class CompleteEntryLink extends AlternateLink {
+    static TYPE: string;
+    constructor(args: OPDSLinkArgs);
+}

package/lib/src/complete_entry_link.js

@@ -0,0 +1,30 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var alternate_link_1 = require("./alternate_link");
+var CompleteEntryLink = /** @class */ (function (_super) {
+    __extends(CompleteEntryLink, _super);
+    function CompleteEntryLink(args) {
+        var _this = this;
+        args.type = CompleteEntryLink.TYPE;
+        _this = _super.call(this, args) || this;
+        return _this;
+    }
+    CompleteEntryLink.TYPE = "application/atom+xml;type=entry;profile=opds-catalog";
+    return CompleteEntryLink;
+}(alternate_link_1.default));
+exports.default = CompleteEntryLink;

package/lib/src/conformance.d.ts

@@ -0,0 +1,6 @@
+export default class Conformance {
+    conformsTo: string | undefined;
+    constructor(args: ConformanceArgs);
+}
+export interface ConformanceArgs extends Conformance {
+}

package/lib/src/conformance.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Conformance = /** @class */ (function () {
+    function Conformance(args) {
+        Object.assign(this, args);
+    }
+    return Conformance;
+}());
+exports.default = Conformance;

package/lib/src/conformance_parser.d.ts

@@ -0,0 +1,7 @@
+import Conformance from "./conformance";
+import Xml2jsOutputParser from "./xml2js_output_parser";
+export default class ConformanceParser extends Xml2jsOutputParser<Conformance> {
+    parse(tag: any): Conformance;
+    private extractConformsTo;
+    private createConformance;
+}

package/lib/src/conformance_parser.js

@@ -0,0 +1,53 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var conformance_1 = require("./conformance");
+var xml2js_output_parser_1 = require("./xml2js_output_parser");
+// this class extends Xml2jsOutputParser
+// to handle parsing of conformance accessibility data
+var ConformanceParser = /** @class */ (function (_super) {
+    __extends(ConformanceParser, _super);
+    function ConformanceParser() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    // parse function gets a tag <conformance>
+    // and extracts Conformance data from it
+    ConformanceParser.prototype.parse = function (tag) {
+        // extract the 'conformsTo' value from the tag
+        // using the helper function.
+        var conformsTo = this.extractConformsTo(tag);
+        // return new Conformance instance
+        return this.createConformance(conformsTo);
+    };
+    // helper function to extract the 'conformsTo' value from the tag
+    ConformanceParser.prototype.extractConformsTo = function (tag) {
+        // Use the existing method to parse the subtag content
+        return this.parseSubtagContent(tag, "conformsTo");
+    };
+    // helper function to create a Conformance instance
+    // from the extracted conformsTo element
+    ConformanceParser.prototype.createConformance = function (conformsTo) {
+        // create a ConformanceArgs object
+        // to hold the extracted data
+        var conformanceArgs = { conformsTo: conformsTo };
+        // return a new Conformance instance
+        // using the collected arguments
+        return new conformance_1.default(conformanceArgs);
+    };
+    return ConformanceParser;
+}(xml2js_output_parser_1.default));
+exports.default = ConformanceParser;

package/lib/src/contributor.d.ts

@@ -0,0 +1,8 @@
+export default class Contributor {
+    name: string;
+    uri: string;
+    role: string;
+    constructor(args: ContributorArgs);
+}
+export interface ContributorArgs extends Contributor {
+}

package/lib/src/contributor.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Contributor = /** @class */ (function () {
+    function Contributor(args) {
+        Object.assign(this, args);
+    }
+    return Contributor;
+}());
+exports.default = Contributor;

package/lib/src/contributor_parser.d.ts

@@ -0,0 +1,5 @@
+import Contributor from "./contributor";
+import Xml2jsOutputParser from "./xml2js_output_parser";
+export default class ContributorParser extends Xml2jsOutputParser<Contributor> {
+    parse(contributor: any): Contributor;
+}

package/lib/src/contributor_parser.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var contributor_1 = require("./contributor");
+var namespace_parser_1 = require("./namespace_parser");
+var xml2js_output_parser_1 = require("./xml2js_output_parser");
+var ContributorParser = /** @class */ (function (_super) {
+    __extends(ContributorParser, _super);
+    function ContributorParser() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ContributorParser.prototype.parse = function (contributor) {
+        var name = this.parseSubtagContent(contributor, "name");
+        var uri = this.parseSubtagContent(contributor, "uri");
+        var opfPrefix = this.prefixes[namespace_parser_1.default.OPF_URI];
+        var role = this.parseAttribute(contributor, opfPrefix + "role");
+        return new contributor_1.default({ name: name, uri: uri, role: role });
+    };
+    return ContributorParser;
+}(xml2js_output_parser_1.default));
+exports.default = ContributorParser;

package/lib/src/copies_parser.d.ts

@@ -0,0 +1,5 @@
+import OPDSCopies from "./opds_copies";
+import Xml2jsOutputParser from "./xml2js_output_parser";
+export default class CopiesParser extends Xml2jsOutputParser<OPDSCopies> {
+    parse(element: any): OPDSCopies;
+}

package/lib/src/copies_parser.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var xml2js_output_parser_1 = require("./xml2js_output_parser");
+var CopiesParser = /** @class */ (function (_super) {
+    __extends(CopiesParser, _super);
+    function CopiesParser() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CopiesParser.prototype.parse = function (element) {
+        var parsed = {
+            total: parseInt(this.parseAttribute(element, "total")),
+            available: parseInt(this.parseAttribute(element, "available")),
+        };
+        return parsed;
+    };
+    return CopiesParser;
+}(xml2js_output_parser_1.default));
+exports.default = CopiesParser;

package/lib/src/entry_parser.d.ts

@@ -0,0 +1,5 @@
+import OPDSEntry from "./opds_entry";
+import Xml2jsOutputParser from "./xml2js_output_parser";
+export default class EntryParser extends Xml2jsOutputParser<OPDSEntry> {
+    parse(entry: any): OPDSEntry;
+}

package/lib/src/entry_parser.js

@@ -0,0 +1,110 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var accessibility_parser_1 = require("./accessibility_parser");
+var opds_entry_1 = require("./opds_entry");
+var partial_opds_entry_1 = require("./partial_opds_entry");
+var complete_entry_link_1 = require("./complete_entry_link");
+var link_parser_1 = require("./link_parser");
+var contributor_parser_1 = require("./contributor_parser");
+var series_parser_1 = require("./series_parser");
+var category_parser_1 = require("./category_parser");
+var namespace_parser_1 = require("./namespace_parser");
+var summary_1 = require("./summary");
+var xml2js_output_parser_1 = require("./xml2js_output_parser");
+var EntryParser = /** @class */ (function (_super) {
+    __extends(EntryParser, _super);
+    function EntryParser() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EntryParser.prototype.parse = function (entry) {
+        var linkParser = new link_parser_1.default(this.prefixes);
+        var atomPrefix = this.prefixes[namespace_parser_1.default.ATOM_URI];
+        var dcPrefix = this.prefixes[namespace_parser_1.default.DC_URI];
+        var schemaPrefix = this.prefixes[namespace_parser_1.default.SCHEMA_URI];
+        var id = this.parseSubtagContent(entry, atomPrefix + "id");
+        var accessibilityParser = new accessibility_parser_1.default(this.prefixes);
+        var accessibility = this.parseSubtag(entry, atomPrefix + "accessibility", accessibilityParser);
+        var updated = this.parseSubtagContent(entry, atomPrefix + "updated");
+        var title = this.parseSubtagContent(entry, atomPrefix + "title");
+        var contributorParser = new contributor_parser_1.default(this.prefixes);
+        var authors = this.parseSubtags(entry, atomPrefix + "author", contributorParser);
+        var contributors = this.parseSubtags(entry, atomPrefix + "contributor", contributorParser);
+        var subtitle = this.parseSubtagContent(entry, schemaPrefix + "alternativeHeadline");
+        var seriesParser = new series_parser_1.default(this.prefixes);
+        var series = this.parseSubtag(entry, schemaPrefix + "Series", seriesParser);
+        var links = this.parseSubtags(entry, atomPrefix + "link", linkParser);
+        var categoryParser = new category_parser_1.default(this.prefixes);
+        var categories = this.parseSubtags(entry, atomPrefix + "category", categoryParser);
+        var rawIdentifiers = entry[dcPrefix + "identifier"];
+        var identifiers;
+        if (rawIdentifiers && rawIdentifiers.length > 0) {
+            identifiers = rawIdentifiers.map(function (identifier) {
+                return identifier["_"];
+            });
+        }
+        else {
+            identifiers = [];
+        }
+        var issued = this.parseSubtagContent(entry, dcPrefix + "issued");
+        var language = this.parseSubtagContent(entry, dcPrefix + "language");
+        var rights = this.parseSubtagContent(entry, atomPrefix + "rights");
+        var publisher = this.parseSubtagContent(entry, dcPrefix + "publisher");
+        var published = this.parseSubtagContent(entry, atomPrefix + "published");
+        var summaryLink;
+        var summaryContent = this.parseSubtagContent(entry, atomPrefix + "content");
+        if (!summaryContent) {
+            var subtag = entry[atomPrefix + "content"];
+            if (subtag && subtag.length > 0) {
+                summaryLink = this.parseAttribute(subtag[0], "src");
+            }
+        }
+        if (!summaryContent) {
+            summaryContent = this.parseSubtagContent(entry, atomPrefix + "summary");
+        }
+        var summary = new summary_1.default({ content: summaryContent, link: summaryLink });
+        var entryClass = opds_entry_1.default;
+        var completeEntryLink = links.find(function (link) {
+            return (link instanceof complete_entry_link_1.default);
+        });
+        if (completeEntryLink) {
+            entryClass = partial_opds_entry_1.default;
+        }
+        return new entryClass({
+            id: id,
+            accessibility: accessibility,
+            updated: updated,
+            title: title,
+            authors: authors,
+            contributors: contributors,
+            subtitle: subtitle,
+            series: series,
+            links: links,
+            categories: categories,
+            identifiers: identifiers,
+            issued: issued,
+            language: language,
+            rights: rights,
+            publisher: publisher,
+            published: published,
+            summary: summary,
+            unparsed: entry
+        });
+    };
+    return EntryParser;
+}(xml2js_output_parser_1.default));
+exports.default = EntryParser;

package/lib/src/feed_parser.d.ts

@@ -0,0 +1,5 @@
+import OPDSFeed from "./opds_feed";
+import Xml2jsOutputParser from "./xml2js_output_parser";
+export default class FeedParser extends Xml2jsOutputParser<OPDSFeed> {
+    parse(feed: any): OPDSFeed;
+}