@mtkruto/node 0.1.200 → 0.1.289

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/FeedHandler.js

@@ -1,191 +0,0 @@
-import DomHandler from './DomHandler.js';
-import * as DomUtils from './utils/mod.js';
-import { Parser } from './Parser.js';
-var FeedItemMediaMedium;
-(function (FeedItemMediaMedium) {
-    FeedItemMediaMedium[FeedItemMediaMedium["image"] = 0] = "image";
-    FeedItemMediaMedium[FeedItemMediaMedium["audio"] = 1] = "audio";
-    FeedItemMediaMedium[FeedItemMediaMedium["video"] = 2] = "video";
-    FeedItemMediaMedium[FeedItemMediaMedium["document"] = 3] = "document";
-    FeedItemMediaMedium[FeedItemMediaMedium["executable"] = 4] = "executable";
-})(FeedItemMediaMedium || (FeedItemMediaMedium = {}));
-var FeedItemMediaExpression;
-(function (FeedItemMediaExpression) {
-    FeedItemMediaExpression[FeedItemMediaExpression["sample"] = 0] = "sample";
-    FeedItemMediaExpression[FeedItemMediaExpression["full"] = 1] = "full";
-    FeedItemMediaExpression[FeedItemMediaExpression["nonstop"] = 2] = "nonstop";
-})(FeedItemMediaExpression || (FeedItemMediaExpression = {}));
-// TODO: Consume data as it is coming in
-export class FeedHandler extends DomHandler {
-    /**
-     *
-     * @param callback
-     * @param options
-     */
-    constructor(callback, options) {
-        if (typeof callback === 'object') {
-            callback = undefined;
-            options = callback;
-        }
-        super(callback, options);
-        Object.defineProperty(this, "feed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-    onend() {
-        const feedRoot = getOneElement(isValidFeed, this.dom);
-        if (!feedRoot) {
-            this.handleCallback(new Error("couldn't find root of feed"));
-            return;
-        }
-        const feed = {};
-        if (feedRoot.name === 'feed') {
-            const childs = feedRoot.children;
-            feed.type = 'atom';
-            addConditionally(feed, 'id', 'id', childs);
-            addConditionally(feed, 'title', 'title', childs);
-            const href = getAttribute('href', getOneElement('link', childs));
-            if (href) {
-                feed.link = href;
-            }
-            addConditionally(feed, 'description', 'subtitle', childs);
-            const updated = fetch('updated', childs);
-            if (updated) {
-                feed.updated = new Date(updated);
-            }
-            addConditionally(feed, 'author', 'email', childs, true);
-            feed.items = getElements('entry', childs).map(item => {
-                const entry = {};
-                const { children } = item;
-                addConditionally(entry, 'id', 'id', children);
-                addConditionally(entry, 'title', 'title', children);
-                const href = getAttribute('href', getOneElement('link', children));
-                if (href) {
-                    entry.link = href;
-                }
-                const description = fetch('summary', children) || fetch('content', children);
-                if (description) {
-                    entry.description = description;
-                }
-                const pubDate = fetch('updated', children);
-                if (pubDate) {
-                    entry.pubDate = new Date(pubDate);
-                }
-                entry.media = getMediaElements(children);
-                return entry;
-            });
-        }
-        else {
-            const childs = getOneElement('channel', feedRoot.children)?.children ?? [];
-            feed.type = feedRoot.name.substr(0, 3);
-            feed.id = '';
-            addConditionally(feed, 'title', 'title', childs);
-            addConditionally(feed, 'link', 'link', childs);
-            addConditionally(feed, 'description', 'description', childs);
-            const updated = fetch('lastBuildDate', childs);
-            if (updated) {
-                feed.updated = new Date(updated);
-            }
-            addConditionally(feed, 'author', 'managingEditor', childs, true);
-            feed.items = getElements('item', feedRoot.children).map((item) => {
-                const entry = {};
-                const { children } = item;
-                addConditionally(entry, 'id', 'guid', children);
-                addConditionally(entry, 'title', 'title', children);
-                addConditionally(entry, 'link', 'link', children);
-                addConditionally(entry, 'description', 'description', children);
-                const pubDate = fetch('pubDate', children);
-                if (pubDate)
-                    entry.pubDate = new Date(pubDate);
-                entry.media = getMediaElements(children);
-                return entry;
-            });
-        }
-        this.feed = feed;
-        this.handleCallback(null);
-    }
-}
-function getMediaElements(where) {
-    return getElements('media:content', where).map(elem => {
-        const media = {
-            medium: elem.attribs.medium,
-            isDefault: !!elem.attribs.isDefault,
-        };
-        if (elem.attribs.url) {
-            media.url = elem.attribs.url;
-        }
-        if (elem.attribs.fileSize) {
-            media.fileSize = parseInt(elem.attribs.fileSize, 10);
-        }
-        if (elem.attribs.type) {
-            media.type = elem.attribs.type;
-        }
-        if (elem.attribs.expression) {
-            media.expression = elem.attribs
-                .expression;
-        }
-        if (elem.attribs.bitrate) {
-            media.bitrate = parseInt(elem.attribs.bitrate, 10);
-        }
-        if (elem.attribs.framerate) {
-            media.framerate = parseInt(elem.attribs.framerate, 10);
-        }
-        if (elem.attribs.samplingrate) {
-            media.samplingrate = parseInt(elem.attribs.samplingrate, 10);
-        }
-        if (elem.attribs.channels) {
-            media.channels = parseInt(elem.attribs.channels, 10);
-        }
-        if (elem.attribs.duration) {
-            media.duration = parseInt(elem.attribs.duration, 10);
-        }
-        if (elem.attribs.height) {
-            media.height = parseInt(elem.attribs.height, 10);
-        }
-        if (elem.attribs.width) {
-            media.width = parseInt(elem.attribs.width, 10);
-        }
-        if (elem.attribs.lang) {
-            media.lang = elem.attribs.lang;
-        }
-        return media;
-    });
-}
-function getElements(tagName, where) {
-    return DomUtils.getElementsByTagName(tagName, where, true);
-}
-function getOneElement(tagName, node) {
-    return DomUtils.getElementsByTagName(tagName, node, true, 1)[0];
-}
-function fetch(tagName, where, recurse = false) {
-    return DomUtils.getText(DomUtils.getElementsByTagName(tagName, where, recurse, 1)).trim();
-}
-function getAttribute(name, elem) {
-    if (!elem) {
-        return null;
-    }
-    const { attribs } = elem;
-    return attribs[name];
-}
-function addConditionally(obj, prop, what, where, recurse = false) {
-    const tmp = fetch(what, where, recurse);
-    if (tmp)
-        obj[prop] = tmp;
-}
-function isValidFeed(value) {
-    return value === 'rss' || value === 'feed' || value === 'rdf:RDF';
-}
-/**
- * Parse a feed.
- *
- * @param feed The feed that should be parsed, as a string.
- * @param options Optionally, options for parsing. When using this option, you should set `xmlMode` to `true`.
- */
-export function parseFeed(feed, options = { xmlMode: true }) {
-    const handler = new FeedHandler(options);
-    new Parser(handler, options).end(feed);
-    return handler.feed;
-}

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/Node.d.ts

@@ -1,168 +0,0 @@
-import { ElementType } from './ElementType.js';
-/**
- * This object will be used as the prototype for Nodes when creating a
- * DOM-Level-1-compliant structure.
- */
-export declare class Node {
-    type: ElementType;
-    /** Parent of the node */
-    parent: NodeWithChildren | null;
-    /** Previous sibling */
-    prev: Node | null;
-    /** Next sibling */
-    next: Node | null;
-    /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */
-    startIndex: number | null;
-    /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */
-    endIndex: number | null;
-    /**
-     *
-     * @param type The type of the node.
-     */
-    constructor(type: ElementType);
-    get nodeType(): number;
-    get parentNode(): NodeWithChildren | null;
-    set parentNode(parent: NodeWithChildren | null);
-    get previousSibling(): Node | null;
-    set previousSibling(prev: Node | null);
-    get nextSibling(): Node | null;
-    set nextSibling(next: Node | null);
-    /**
-     * Clone this node, and optionally its children.
-     *
-     * @param recursive Clone child nodes as well.
-     * @returns A clone of the node.
-     */
-    cloneNode<T extends Node>(this: T, recursive?: boolean): T;
-}
-/**
- * A node that contains some data.
- */
-export declare class DataNode extends Node {
-    data: string;
-    /**
-     * @param type The type of the node
-     * @param data The content of the data node
-     */
-    constructor(type: ElementType.Comment | ElementType.Text | ElementType.Directive, data: string);
-    get nodeValue(): string;
-    set nodeValue(data: string);
-}
-/**
- * Text within the document.
- */
-export declare class Text extends DataNode {
-    constructor(data: string);
-}
-/**
- * Comments within the document.
- */
-export declare class Comment extends DataNode {
-    constructor(data: string);
-}
-/**
- * Processing instructions, including doc types.
- */
-export declare class ProcessingInstruction extends DataNode {
-    name: string;
-    constructor(name: string, data: string);
-    'x-name'?: string;
-    'x-publicId'?: string;
-    'x-systemId'?: string;
-}
-/**
- * A `Node` that can have children.
- */
-export declare class NodeWithChildren extends Node {
-    children: Node[];
-    /**
-     * @param type Type of the node.
-     * @param children Children of the node. Only certain node types can have children.
-     */
-    constructor(type: ElementType.Root | ElementType.CDATA | ElementType.Script | ElementType.Style | ElementType.Tag, children: Node[]);
-    get firstChild(): Node | null;
-    get lastChild(): Node | null;
-    get childNodes(): Node[];
-    set childNodes(children: Node[]);
-}
-/**
- * The root node of the document.
- */
-export declare class Document extends NodeWithChildren {
-    constructor(children: Node[]);
-    'x-mode'?: 'no-quirks' | 'quirks' | 'limited-quirks';
-}
-/**
- * The description of an individual attribute.
- */
-interface Attribute {
-    name: string;
-    value: string;
-    namespace?: string;
-    prefix?: string;
-}
-/**
- * An element within the DOM.
- */
-export declare class Element extends NodeWithChildren {
-    name: string;
-    attribs: {
-        [name: string]: string;
-    };
-    /**
-     * @param name Name of the tag, eg. `div`, `span`.
-     * @param attribs Object mapping attribute names to attribute values.
-     * @param children Children of the node.
-     */
-    constructor(name: string, attribs: {
-        [name: string]: string;
-    }, children?: Node[], type?: ElementType.Tag | ElementType.Script | ElementType.Style);
-    get tagName(): string;
-    set tagName(name: string);
-    get attributes(): Attribute[];
-    'x-attribsNamespace'?: Record<string, string>;
-    'x-attribsPrefix'?: Record<string, string>;
-}
-/**
- * @param node Node to check.
- * @returns `true` if the node is a `Element`, `false` otherwise.
- */
-export declare function isTag(node: Node): node is Element;
-/**
- * @param node Node to check.
- * @returns `true` if the node has the type `CDATA`, `false` otherwise.
- */
-export declare function isCDATA(node: Node): node is NodeWithChildren;
-/**
- * @param node Node to check.
- * @returns `true` if the node has the type `Text`, `false` otherwise.
- */
-export declare function isText(node: Node): node is Text;
-/**
- * @param node Node to check.
- * @returns `true` if the node has the type `Comment`, `false` otherwise.
- */
-export declare function isComment(node: Node): node is DataNode;
-/**
- * @param node Node to check.
- * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.
- */
-export declare function isDirective(node: Node): node is ProcessingInstruction;
-/**
- * @param node Node to check.
- * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.
- */
-export declare function isDocument(node: Node): node is Document;
-/**
- * @param node Node to check.
- * @returns `true` if the node is a `NodeWithChildren` (has children), `false` otherwise.
- */
-export declare function hasChildren(node: Node): node is NodeWithChildren;
-/**
- * Clone a node, and optionally its children.
- *
- * @param recursive Clone child nodes as well.
- * @returns A clone of the node.
- */
-export declare function cloneNode<T extends Node>(node: T, recursive?: boolean): T;
-export {};