Install mediaxml with npm:

$ npm install mediaxml

Or add to package.json:

{
  "dependencies": {
    "mediaxml": "^0.4.0"
  }
}

See the Getting Started guide for more information on using the mediaxml module.

The mediaxml module provides various implementations of XML formats for describing media packages, manifests, and feeds such as RSS, mRSS, ADI, and XMLTV.

Simple Example

In the example below, we parse a rss feed and enumerate all of the items in the document's channel.

const path = require('path')
const rss = require('mediaxml/rss')
const fs = require('fs')

const stream = fs.createReadStream('feed.rss')
const document = rss.createDocument(stream)

document.ready(() => {
  for (const item of document.channel.items) {
    console.log(item.title, item.description, item.link)
  }
})

Parsing Documents

Parsing a XML document using streams:

const { Parser } = require('mediaxml/parser')
const path = require('path')
const fs = require('fs')

const stream = fs.createReadStream('epg.xml')
const parser = new Parser()

stream.pipe(parser.createWriteStream()).on('finish', () => {
  console.log(parser.rootNode.sourceInfoUrl, parser.rootNode.sourceInfoName)
  console.log(parser.rootNode.children)
  parser.createReadStream().pipe(process.stdout)
})

Querying the Document Object Model

The query API is a powerful tool for querying the document object model produced by the parser using JSONata query syntax with a preprocessor syntax.

const { rootNode } = parser

// query root node decendent nodes with tag name "channel"
const channels = rootNode.query('[name="channel"]')

// query root node decendent nodes with a tag name "programme"
const programmes = rootNode.query('[name="programme"]')

// query all nodes in document with tag name "category"
// and select the text content (selected with the `:text` preprocessor function)
const categories = rootNode.query('**[name="category"]:text')

// query all nodes in document with tag name "programme"
// an `start` attribute (selected with the `attr()` preprocessor function)
// integer value greater than todays
const programmesInFuture = rootNode.query(`[
  name = "programmes" AND
  $int(attr(start)) > $int("${Date()}")
]`)

Creating Documents

const { createDocument } = require('mediaxml/document')

const document = createDocument({ nodeName: 'ADI' })
const metadata = document.createChild('Metadata')

metadata.createChild('AMS', {
  Asset_Class: 'package',
  Provider_ID: 'mylifetime.com',
  Provider: 'LIFETIMEMOVIECLUB_HD_UNIFIED',
  Product: 'SVOD',
  ...
})

metadata.createChild('App_Data', {
  App: 'SVOD',
  Name: 'Metadata_Spec_Version',
  Value: 'CableLabsVOD1'
})

metadata.createChild('App_Data', {
  App: 'SVOD',
  Name: 'Provider_Content_Tier',
  Value: 'LIFETIMEMOVIECLUB_HD_UNIFIED'
})

console.log(document.toString())
// <ADI>
//   <Metadata>
//     <AMS Asset_Class="package" Product="SVOD" Provider="LIFETIMEMOVIECLUB_HD_UNIFIED" Provider_ID="mylifetime.com" Verb="" Version_Major="3" Version_Minor="0" Creation_Date="2020-09-29" Description="AcquiredMovie_FriendsWhoKill_241958-package" Asset_ID="LFHP2419582007240000" Asset_Name="LFHP2419582007240000_AMVE_HD" />
//     <App_Data App="SVOD" Name="Metadata_Spec_Version" Value="CableLabsVOD1.1" />
//     <App_Data App="SVOD" Name="Provider_Content_Tier" Value="LIFETIMEMOVIECLUB_HD_UNIFIED" />
//   </Metadata>
// </ADI>

See Also

• RSS
• mRSS
• ADI
• ADI3
• XMLTV

General Usage

The mediaxml module exports various APIs that allow for the parsing and building of XML documents intended for media packaging and metadata purposes. This includes support for metadata package specifications like CableLabsVOD1.1 (ADI) and SCTE-236 (ADI3) as well support for feeds like RSS, mRSS, and XMLTV. The mediaxml module provides low level components for parsing and building documents in a variety of ways that make this a convenient tool. The document object defined by mediaxml can be queried with a JSONata syntax extended with special selectors

Parsing Documents

XML documents can be parsed easily with the Parser class from the mediaxml/parser module.

const { Parser } = require('mediaxml/parser')

The Parser class can provide a Writable stream interface a Readable stream can pipe to.

const parser = new Parser()
process.stdin.pipe(parser.createWriteStream()).on('finish', () => {
  console.log(parser.rootNode)
})

The Parser instance can be directly written to.

const parser = new Parser()
parser.write(source)
parser.end()

The static Parser.from(input) function can be convenient for creating a Parser instance from an input string (or stream).

const parser = Parser.from(source)

The Parser instance state can be serialized with the parser.toString() function.

const sourceString = parser.toString()

Querying Document Object Model

Document nodes can be queried using "JSONata" query syntax with special selector syntax for working with Node (ParserNode) instances represented by a document object model.

See the query(node, query, opts) for more information on how the API works and how to query the node hierarchy.

Below are a few examples.

// select first node in document with node name "channel"
const channel = document.query('[name="channel"]:first')

// select the 'href' attribute value from the first child with a node name
// of "atom:link" from the first "channel" node
const atom = document.query('[name="channel"]:first:children:first[name="atom:link"]:attr(href)')

// select the text of the first node with a name that matches the
`/^offer:BillingId$/i` regular expression
const billingId = document.query('**[name ~> /^offer:BillingId$/i]:first:text')

Document & Node Building

Documents can be created easily with the createDocument(source) and createNode(name, attributes, body) factory functions in the mediaxml/document module.

const { createDocument, createNode } = require('mediaxml/document')

Documents can be created inline from a source string or from a stream as input.

const document = createDocument(`
<package>
  <assets />
</package>
`)

console.log('%s', document)
// <package>
//   <assets />
// </package>

Nodes can be created easily with createNode(name, attributes, body) and appended to the document with document.appendChild(child)

document.appendChild(createNode('asset', {
  name: 'first',
  url: 'https://example.com/first.mp4'
}))

document.appendChild(createNode('asset', {
  name: 'second',
  url: 'https://example.com/second.mp4'
}))

console.log('%s', document)
// <package>
//   <assets>
//     <asset name="first" url="https://example.com/first.mp4" />
//     <asset name="second" url="https://example.com/second.mp4" />
//   </assets>
// </package>

Querying the nodes of the document should work as expected with the document.query(query) function.

const assets = document.query('**[name="asset"]')
console.log(assets) // a `ParserNodeFragment` is just a fancy `Array`
// ParserNodeFragment(2) [
//   <asset name="first" url="https://example.com/first.mp4" />,
//   <asset name="second" url="https://example.com/second.mp4" />
// ]

const urls = document.query('**[name="asset"]:attr(url)')
console.log(urls)
// [ 'https://example.com/first.mp4', 'https://example.com/second.mp4 ]

Custom Documents

Custom documents can be created easily by extending the Document and Node classes.

const { Document, Node } = require('mediaxml/document')

class Channel extends Node {
  get name() {
    return this.query('[name="name"]:first:text') || null
  }
}

class CustomDocument extends Document {
  get channels() {
    const results = this.query('[name="channel"]')
    return (results ? [].concat(results) : []).map((r) => Channel.from(r))
  }
}

const document = CustomDocument.from(`
  <package>
    <channel>
      <name>Channel A</name>
    </channel>
    <channel>
      <name>Channel B</name>
    </channel>
  </package>
`)

console.log(document.channels)
console.log(document.query('channels.name'))

Query Preprocessor

Queries are preprocessed to handle special syntax as sugar on top of JSONata syntax.

Selectors

:children([index[, count]])

Selects children from an object that has a children field value. Values from the children array can be sliced optionally when called with functional syntax children(start, count).

$:children(2, 4) /** slices 4 children from the root starting at index 2 */

[:]attr([name])

Selects an attribute value of by name from an object that has an attribute field value.

**:attr(url) /** selects "url" attribute from any node */

:text

Selects text value from an object that has a text field value.

**:text /** selects text value from any node */

Ordinals

Ordinals as selectors like :first and :last can be used to reference the first and last elements in an array. Ordinals like :second, :third, :fourth all the way to up :tenth can be used to reference their corresponding element in an array.

:first

Selects the first element in an array.

$:children:first /** This is the same as $.children[0] */

:second

Selects the second element in an array.

$:children:second /** This is the same as $.children[1] */

:third

Selects the third element in an array.

$:children:third /** This is the same as $.children[2] */

:fourth

Selects the fourth element in an array.

$:children:fourth /** This is the same as $.children[3] */

:fifth

Selects the fifth element in an array.

$:children:fifth /** This is the same as $.children[4] */

:sixth

Selects the sixth element in an array.

$:children:sixth /** This is the same as $.children[5] */

:seventh

Selects the seventh element in an array.

$:children:seventh /** This is the same as $.children[6] */

:eighth

Selects the eighth element in an array.

$:children:eighth /** This is the same as $.children[7] */

:ninth

Selects the ninth element in an array.

$:children:ninth /** This is the same as $.children[8] */

:tenth

Selects the tenth element in an array.

$:children:tenth /** This is the same as $.children[9] */

:last

Selects the last element in an array.

$:children:last /** This is the same as $.children[-1] */

Operators

is

Comparison operator that compares values in a variety of ways.

is [not] <string|array|number|boolean|object|function>

Compares value to a primitive type.

/** finds all nodes with an url attribute that is a non-empty string */
**[attr(url) is string and attr(url) is not empty]

is [not] <null|true|false|NaN|Infinity>

Compares value to a constant type.

/** finds all nodes with an role attribute that is not null */
**[attr(role) is not null]

is [not] <Date|Document|Node|Fragment|Text>

Compares value to a class type.

/** finds any value that is a `Date` instance */
**[is Date]

is [not] <expr>

Compares value to right hand expression.

/** finds any node where the url attribute is not a "bad url" */
**[attr(url) is not "bad url"]

as

Casting operator that can cast values to a variety of other values.

as <array|boolean|float|function|int|number|object|string>

Cast a value to a primitive type.

123 as boolean /** true */
456 as string /** '456' */
123.456 as int /** 123 */
'0.12300' as float /** 0.123 */
'abc' as array /** ['a', 'b', 'c'] */
123 as string as array /** [] */

as <false|true|NaN|null>

Cast a value to a constant type.

123 as false /** false */
"foo" as true /** true */
0 as null /** null */
123 as NaN /** NaN */

as <Date|Document|Fragment|Node|Text>

Cast a value to an instance type.

"2020-04-20" as Date /** 2020-04-20T00:00:00.000Z */

as camelcase

Cast a value to a camel cased string.

"hello world" as camelcase /** helloWorld */

as pascalcase

Cast a value to a pascal cased string.

"hello world" as camelcase /** HelloWorld */

as snakecase

Cast a value to a snake cased string.

"hello world" as camelcase /** hello_world */

as json

Cast a value to a parsed JSON.

'{"hello": "world"}' as json /** { hello: 'world' } */

as keys

Cast a value to an enumeration of its keys.

({"hello": true, "world": false}) as keys /** ['hello', 'world'] */

as sorted

Cast a value to a sorted array.

([3, 2, 1, 'a', 'b']) as sorted /** [1, 2, 3, 'a', 'b'] */

as reversed

Cast a value to a reversed string or array.

'123cba' as reversed /** 'abc321' */

as unique

Cast a value to an array or string with unique elements

'aabbccdd' as unique /** 'abcd' */

as tuple

Cast a value to tuple with key and value pairs.

({"hello": "world"}) as tuple /** { key: 'hello', value: 'world' } */

let <key> = <value>

Sets a global variable for the execution of the query.

let a = 1;
let b = 2;
let c = $a + $b; /** 3 */
let key = 'd';
let $key = $c + 2; /** 5 */
print $d /** 5 */

[target] has <subject>

Check if <subject> is a property of target. Optionally, this operator can be used in a query with the target omitted as it is implicitly inferred.

({ "foo": "bar" }) has "foo" // true

**[attributes has url] // returns all nodes that have a "url" attribute

**:attributes[has url] // returns all attributes that have a "url" field

typeof <target>

Computes the type of target as a string.

typeof "foo" // 'string'
typeof ({}) // 'object'
typeof 123 // 'number'

import <URI>

Import a XML file or query string from a given URI. A valid URI can be a HTTP(S) resource or a file path (optionally specified with file://). The import operator requires a runtime loader. A runtime loader is given for the mxml(1) command.

import 'https://raw.githubusercontent.com/little-core-labs/mediaxml/master/example/mrss/feed.xml'

**[is text and is not empty]

[target] contains <data>

Checks if data is contained by target.

Casting

Types can be casted to and from a variety of types.

Primitives

'123' as int // 123

'123.456' as int // 123

0 as boolean // false

1 as boolean // true

123 as string // '123'

123 as int<16> // 291

'abc' as array // ['a', 'b', 'c']

Specials

$now() as Date // 2021-03-08T19:54:26.205Z

'{"hello": "world"}' as json // { hello: 'world' }

this as json // { name: '#empty', text: '', attributes: {}, children: [] }

let $xml = '<rss><channel><title>hello</title></channel></rss>'
$xml as Node
/**
 * <rss>
 *   <channel>
 *     <title>hello</title>
 *   </channel>
 * </rss>
 */

String Casing

'hello world' as CamelCase // helloWorld

'hello world' as SnakeCase // hello_world

'hello world' as PascalCase // HelloWorld

Transforms

'fbdeca' as sorted // 'abcdef'

([3,2,1]) as sorted // [3, 2, 1]

({"d": 1, "c": 2, "b": 3, "a": 4}) as json as sorted
/**
 * {
 *   a: 4,
 *   b: 3,
 *   c: 2,
 *   d: 1
 * }
 */

this as text // `<#empty />`

JSONata Function Bindings

In addition to the already built-in JSONata functions , the following functions are registered as JSONata syntax functions and can be used in the query string.

Reflection

This section contains functions for reflecting runtime values such as class constructor names or instance primitive type names.

$typeof(<j-:s>)

Returns the type of input as a string. This function will return array for arrays, date for Date instances, otherwise typeof input.

$typeof("string") // string
$typeof(123) // number

$classConstructorName(<j-:s>)

Returns the class constructor name for given input. This function will always return a string.

Transform

This section contains functions for transforming input into a new output.

$tuple(<j-:a>)

Convert input into {key: ..., value: ...} pairs.

mxml (epg.xml)> **:attrs.$tuple() /** map all attributes to the `$tuple()` */
{
  key: 'source-info-url',
  value: 'http://www.schedulesdirect.org/'
}
{
  key: 'source-info-name',
  value: 'Schedules Direct'
}
...

$keys(<j-:a>)

Returns computed keys of input as an array.

$json(<j-j?:j>)

Converts input into a plain JSON object (parsed).

$array(<j-:a>)

Converts input to an array.

$date(<j-:o>)

Converts input into a date.

$int(<j-j?:n>)

Converts input into an integer.

$float(<j-j?:n>)

Converts input into a float.

$boolean(<j-:b>)

Converts input into a boolean.

$string(<j-j?:s>)

Converts input into a string.

$true(<j-:b>)

Returns true for any input.

$false(<j-:b>)

Returns false for any input.

Strings

$camelcase(<s-:s>)

Converts input string to camelcase.

$length(<j-:n>)

Returns the length of input string.

Arrays

$concat(<a<j->:a>)

Returns concatenated variable input as an array.

$length(<j-:n>)

Returns the length of input array.

$unique(<j-:a>)

Returns input array with only unique elements.

$slice(<j-:a>)

Returns a slice of an array or parser node.

$join(<a-s?:s>)

Returns an array joined by a given delimiter (default: ",").

$isArray(<j-:b>)

Returns true if input is an array, otherwise false.

Utility

$print(<j-:l>)

Prints variable input to stdout.

$now(<j-:n>)

Returns the UNIX Epoch in milliseconds.

The mediaxml module ships with a command line interface program for running queries targeted at an XML document. The program is called mxml and can be invoked like mxml <filename> <query>. The filename can be a fully qualified URL or a path to a file on disk.

Usage

usage: mxml [-hiDV] [options] <filename> [query]

options:
  -h, --help      Show this message
  -i, --inspect   Show inspected output
  -D, --debug     Show debug output
  -V, --version   Show program version

arguments:
  <filename>      Path to XML file (required)
  [query]         Query in JSONata syntax on resulting model [optional]

examples:
  ## read ADI metadata
  mxml ./tvshow.xml 'adi:children[name = "Metadata"]'

  ## look for ADI3 "Movie" assets
  mxml ./movie.xml 'adi3:children[`xsi:type` = "content:MovieType"]'

Examples

Query <App_Data /> nodes that are children of the first <Metadata /> node in an ADI document.

$ mxml ./tvshow.xml ':root :children[name = "Metadata"]:first :children[name = "App_Data"]'

Query all <title /> node text values in all <item /> nodes in a RSS or mRSS document.

$ mxml ./feed.rss ':root :children[name = "item"] :children[name = "title"] :text'

Start a repl session with debug mode enabled.

$ mxml ./feed.rss --debug
mxml (feed.xml)>

REPL Mode

The mxml command can also be used to initiate a repl session for interactively querying the document object module of an XML document.

$ mxml ./feed.rss
mxml (feed.xml)> :root:name /** query the name of the root node */
rss
query: 42.626ms
mxml (feed.xml)> $unique(**[is node]:name) /** query the name of all nodes in the document */
rss
channel
title
link
language
pubDate
lastBuildDate
managingEditor
description
image
url
height
width
atom:link
item
guid
media:category
media:content
media:title
media:description
media:thumbnail
media:credit
media:copyright
mxml (feed.xml)>

See Also

• Getting Started
• Query User Guide
• REPL

The mediaxml module ships with a command line program that provides a repl for interactive sessions to explore the contents of an XML file and its corresponding node hierarchy.

To start a session, simply run the mxml command specifying a filename. The filename can be a fully qualified URL, or a relative path to a file. The file is loaded and parsed before the session is started.

Debug output can be enabled with the --debug flag upon starting that program.

Starting a new session should look like:

$ mxml feed.rss
mxml (feed.xml)>

The smallest query we can run is the :root query (or $ in JSONata syntax) which should yield the root of the document.

mxml (feed.xml)> :root
<rss xmlns:atom="http://www.w3.org/2005/Atom" xmlns:media="http://search.yahoo.com/mrss/" version="2.0">
  <channel>
    <title>Calm Meditation</title>
    ...

The attributes of the root node can be queried with the :attr selector.

mxml (feed.xml)> :root:attr
ParserNodeAttributes {
  'xmlns:atom': 'http://www.w3.org/2005/Atom',
  'xmlns:media': 'http://search.yahoo.com/mrss/',
  version: 2
}
query: 9.114ms

An attribute value can be queried by specifying the name of the attribute as an argument to the :attr(name) selector.

mxml (feed.xml)> :root:attr(xmlns:media)
http://search.yahoo.com/mrss/
query: 41.854ms
mxml (feed.xml)> :root:attr(xmlns:atom)
http://www.w3.org/2005/Atom
query: 3.631ms
mxml (feed.xml)> :root:attr(version)
2
query: 4.891ms

The mediaxml module exports a variety of high level modules documented in the following sections such as mediaxml/adi, and mediaxml/xmltv and more.

const adi = require('mediaxml/adi')
const adi3 = require('mediaxml/adi3')
const mrss = require('mediaxml/mrss')
const rss = require('mediaxml/rss')
const xmltv = require('mediaxml/xmltv')

See

• https://community.cablelabs.com/wiki/plugins/servlet/cablelabs/alfresco/download?id=8f900e8b-d1eb-4834-bd26-f04bd623c3d2

static

new Document(input: (adi.Document | Parser | String | ReadableStream), opts: Object?)

const fs = require('fs')
const stream = fs.createReadStream('./package.xml')
const document = Document.from(stream)

document.ready(() => {
  console.log(document.metadata)
  console.log(document.asset)
})

new Metadata(document: Document, node: ParserNode)

new AMS(document: Document, node: ParserNode)

new AppData(document: Document, node: ParserNode)

new Content(document: Document, node: ParserNode)

new Asset(document: Document, node: ParserNode)

createDocument(args: ...any): Document

A module to provide atomic classes for working with ADI3 documents.

See

• {@link https://scte-cms-resource-storage.s3.amazonaws.com/ANSI_SCTE-35-2019a-1582645390859.pdf}

static

new Document(input: (Document | Parser | String | ReadableStream), opts: Object?)

const fs = require('fs')
const stream = fs.createReadStream('./package.xml')
const document = Document.from(stream)

document.ready(() => {
  console.log(document.metadata)
  console.log(document.asset)
})

new Asset(document: Document, node: ParserNode)

new SubscriberViewLimit(document: Document, node: ParserNode)

new AlternateId(document: Document, node: ParserNode)

new Extension(document: Document, node: ParserNode)

new EncryptionInfo(document: Document, node: ParserNode)

new CopyControlInfo(document: Document, node: ParserNode)

new Rating(document: Document, node: ParserNode)

new DistributorRoyaltyInfo(document: Document, node: ParserNode)

new StudioRoyaltyInfo(document: Document, node: ParserNode)

new LocalizableTitle(document: Document, node: ParserNode)

new Actor(document: Document, node: ParserNode)

new Director(document: Document, node: ParserNode)

new Chapter(document: Document, node: ParserNode)

new Presentation(document: Document, node: ParserNode)

createDocument(args: ...any): Document

A module to provide atomic classes for working with RSS documents.

See

• {@link https://validator.w3.org/feed/docs/rss2.html}

static

new Document(input: (Document | Parser | String | ReadableStream), opts: Object?)

const fs = require('fs')
const stream = fs.createReadStream('./feed.rss')
const document = Document.from(stream)

document.ready(() => {
  console.log(document.channel.items)
})

new Channel(document: Document, node: ParserNode)

new TextInput(document: Document, node: ParserNode)

new Image(document: Document, node: ParserNode)

new Category(document: Document, node: ParserNode)

new Item(document: Document, node: ParserNode)

new Source(document: Document, node: ParserNode)

new Enclosure(document: Document, node: ParserNode)

createDocument(args: ...any): Document

A module to provide atomic classes for working with mRSS documents.

See

• {@link https://www.rssboard.org/media-rss}

static

new Document(input: (Document | Parser | String | ReadableStream), opts: Object?)

new Channel(document: Document, node: ParserNode)

new Item(document: Document, node: ParserNode)

new MediaGroup(document: Document, node: ParserNode)

new MediaContent(document: Document, node: ParserNode)

new MediaPlayer(document: Document, node: ParserNode)

new MediaRating(document: Document, node: ParserNode)

new MediaTitle(document: Document, node: ParserNode)

new MediaDescription(document: Document, node: ParserNode)

new MediaThumbnail(document: Document, node: ParserNode)

new MediaCategory(document: Document, node: ParserNode)

new MediaHash(document: Document, node: ParserNode)

new MediaCredit(document: Document, node: ParserNode)

new MediaCopyright(document: Document, node: ParserNode)

new MediaText(document: Document, node: ParserNode)

new MediaRestriction(document: Document, node: ParserNode)

new MediaCommunity(document: Document, node: ParserNode)

new MediaEmbed(document: Document, node: ParserNode)

new MediaEmbedParameters(document: Document, node: ParserNode)

new MediaStatus(document: Document, node: ParserNode)

new MediaPrice(document: Document, node: ParserNode)

new MediaLicense(document: Document, node: ParserNode)

new MediaSubTitle(document: Document, node: ParserNode)

new MediaPeerLink(document: Document, node: ParserNode)

new MediaRights(document: Document, node: ParserNode)

new MediaLocation(document: Document, node: ParserNode)

new MediaScene(document: Document, node: ParserNode)

createDocument(args: ...any): Document

A module to provide atomic classes for working with XMLTV documents.

See

• {@link http://wiki.xmltv.org/index.php/XMLTVFormat}

• {@link https://github.com/XMLTV/xmltv/blob/master/xmltv.dtd}

static

new Document(input: (Document | Parser | String | ReadableStream), opts: Object?)

const fs = require('fs')
const stream = fs.createReadStream('./epg.xml')
const document = Document.from(stream)

document.ready(() => {
  console.log(document.channels)
  console.log(document.programmes)
})

new LocalizedTextEntity(document: Document, node: ParserNode)

new DisplayName(document: Document, node: ParserNode)

new Title(document: Document, node: ParserNode)

new SubTitle(document: Document, node: ParserNode)

new Description(document: Document, node: ParserNode)

new Category(document: Document, node: ParserNode)

new Language(document: Document, node: ParserNode)

new OriginalLanguage(document: Document, node: ParserNode)

new Icon(document: Document, node: ParserNode)

new AudioDescription(document: Document, node: ParserNode)

new VideoDescription(document: Document, node: ParserNode)

new StarRating(document: Document, node: ParserNode)

new Rating(document: Document, node: ParserNode)

new Credits(document: Document, node: ParserNode)

new EpisodeNumber(document: Document, node: ParserNode)

new Channel(document: Document, node: ParserNode)

new Programme(document: Document, node: ParserNode)

createDocument(args: ...any): Document

The mediaxml module exports a variety of core modules documented in the following sections such as mediaxml/parser, mediaxml/query, mediaxml/document, and more.

const document = require('mediaxml/document')
const entity = require('mediaxml/entity')
const normalize = require('mediaxml/normalize')
const parser = require('mediaxml/parser')
const query = require('mediaxml/query')

A core module for working with and building XML documents. The interfaces provided by this module are porcelain and be used instead of the parser API.

See

• ParserNode

static

new Node(name: String, attributes: Object?, depth: Number?, opts: Object?)

new AbstractDocument(parser: Parser, opts: Object?)

new Document(parser: Parser, opts: Object?)

createDocument(args: ...any): Document

createNode(args: ...any): Node

A module for the base Entity used as a base class for various porcelain classes.

static

new Entity(document: Document, node: ParserNode)

const { Entity } = require('mediaxml/entity')

class Programme extends Entity {
  get channel() {
    return this.attributes.channel
  }
}

const node = document.query('[name="programme"]')
const programme = Programme.from(document, node)
console.log(programme.channel)

A module that provides various normalization functions.

static

normalizeValue(value: any?): any?

console.log(normalizeValue())
// null

console.log(normalizeValue(true))
// true

console.log(normalizeValue(false))
// true

console.log(normalizeValue('foo'))
// 'foo'

console.log(normalizeValue('123.45'))
// 123.45

console.log(normalizeValue('2021-01-23T18:12:42.963Z'))
// Date (2021-01-23T18:12:42.963Z)

console.log('NPT Timecode', normalizeValue('00:45))
// Timecode (00:00:45-) { start: Time (00:45:32) { value: 2732 }, ... }

console.log('SMPTE Timecode', normalizeValue('00:45:32;00'))
// Timecode  { frameRate: 29.97, dropFrame: true, .... }

console.log('ISO-8601 Duration', normalizeValue('P1Y2M3DT4H5M6S'))
// { years: 1, months: 2, days: 3, ... }

normalizeAttributes(attributes: any, opts: Object?, attribute: Object): Object

const attrs = normalizeAttributes({ Time_Code: '00:01.5-01:00' })
console.log(attrs.timeCode)
// Timecode (00:00:01.5-00:01:00) {
//   start: Time (00:00:01.5) { value: 1.5 },
//   stop: Time (00:01:00) { value: 60 }
// }

normalizeKey(key: String, opts: Object?): String

console.log(normalizeKey('Asset_ID'))
// 'assetId'

console.log(normalizeKey('Asset_ID'), { preserveConsecutiveUppercase: true })
// 'assetID'

normalizeAttributeKey(key: String, opts: Object?): String

console.log(normalizeAttributeKey('Provider_ID'))
// 'providerID'

console.log(normalizeAttributeKey('Provider_ID'), { preserveConsecutiveUppercase: false })
// 'providerId'

normalizeAttributeValue(value: String): String

console.log(normalizeAttributeValue('2021-01-23T18:12:42.963Z'))
// Date (2021-01-23T18:12:42.963Z)

The core parsing API for the MediaXML module that creates a document object model for a parsed XML file with a robust query API built on top of JSONata.

static

new ParserNodeAttributes(attributes: Object?, opts: Object?)

new ParserNodeText(text: String, opts: any, depth: any)

new ParserNodeCDATA()

new ParserNodeFragment(attributes: Object?, opts: Object?)

new ParserNode(name: String, attributes: Object?, depth: Number?, opts: Object?)

const metadata = ParserNode.from('Metadata')
const appData = ParserNode.from('App_Data', { app: 'SVOD', name: 'Type', value: 'title' })
metadata.appendChild(appData)

console.log(metadata)
// <Metadata>
//   <App_Data app="SVOD" name="Type" value="title" />
// </Metadata>

new ParserState(stack: Array?)

new ParserHandler()

new ParserOptions(opts: Object?)

new Parser(opts: ParserOptions?)

Module exports.

static

cache: Map

const { cache } = require('mediaxml/query')
// clear the query cache of all entries (compiled expressions, etc)
cache.clear()

new Imports(opts: Object)

new Assignments()

new Context(opts: Object)

new Expression(context: any, string: String, opts: Object?)

new Transforms(context: Context, transforms: ...any)

new Bindings(context: Context, entries: ...any)

query(node: ParserNode?, queryString: String?, opts: Object?): (ParserNode | ParserNodeFragment | String | any)?

// select first node with node name "channel"
const channel = query(node, '[name="channel"]:first')

// select the 'href' attribute value from the first child with a node name
// of "atom:link" from the first "channel" node
const atom = query(node, '[name="channel"]:first:children:first[name="atom:link"]:attr(href)')

// select the text of the first node with a name that matches the
`/^offer:BillingId$/i` regular expression
const billingId = query(node, '[name ~> /^offer:BillingId$/i]:first:text')

A module that provides a container for fragment nodes.

static

new Fragment()

A module to provide XML validation.

See

• {@link https://github.com/NaturalIntelligence/fast-xml-parser}

static

new ValidationError(code: String, message: String, opts: Object?)

validate(xml: String, opts: any): Boolea

A module that provides a container for text nodes.

static

new Text()