imsc
Version:
Renders IMSC documents to HTML5 fragments
404 lines • 11.4 kB
TypeScript
/**
* @module imscDoc
*/
/**
* @typedef {import("./error").ErrorHandler} ErrorHandler
* @typedef {import("./parser").Node} Node
* @typedef {import("./parser").Parser} Parser
*/
/**
* Allows a client to provide callbacks to handle children of the <metadata> element
* @typedef {Object} MetadataHandler
* @property {?OpenTagCallBack} onOpenTag
* @property {?CloseTagCallBack} onCloseTag
* @property {?TextCallBack} onText
*/
/**
* Called when the opening tag of an element node is encountered.
* @callback OpenTagCallBack
* @param {string} ns Namespace URI of the element
* @param {string} name Local name of the element
* @param {Record<string, {uri: string, name: string, value: string}>} attributes List of attributes, each consisting of a
* `uri`, `name` and `value`
*/
/**
* Called when the closing tag of an element node is encountered.
* @callback CloseTagCallBack
*/
/**
* Called when a text node is encountered.
* @callback TextCallBack
* @param {string} contents Contents of the text node
*/
/**
* Parses an IMSC1 document into an opaque in-memory representation that exposes
* a single method <pre>getMediaTimeEvents()</pre> that returns a list of time
* offsets (in seconds) of the ISD, i.e. the points in time where the visual
* representation of the document change. `metadataHandler` allows the caller to
* be called back when nodes are present in <metadata> elements.
*
* @param {string} xmlstring XML document
* @param {ErrorHandler} errorHandler Error callback
* @param {?MetadataHandler} metadataHandler Callback for <Metadata> elements
* @param {Parser} parser XML parser
* @returns {?TTElement} Opaque in-memory representation of an IMSC1 document
*/
export function fromParser(xmlstring: string, errorHandler: ErrorHandler, metadataHandler: MetadataHandler | null, parser: Parser): TTElement | null;
export class ForeignElement {
constructor(node: any);
node: any;
}
export class TTElement {
/**
* @type {number[]}
*/
events: number[];
head: HeadElement;
/**
* @type {?BodyElement}
*/
body: BodyElement | null;
/**
* @param {Node} node
* @param {string} xmllang
* @param {ErrorHandler} errorHandler
*/
initFromNode(node: Node, xmllang: string, errorHandler: ErrorHandler): void;
cellLength: {
h: ComputedLength;
w: ComputedLength;
} | undefined;
effectiveFrameRate: number | undefined;
tickRate: number | undefined;
aspectRatio: number | null | undefined;
pxLength: {
h: null;
w: null;
} | {
h: ComputedLength;
w: ComputedLength;
} | undefined;
/** set root container dimensions to (1, 1) arbitrarily
* the root container is mapped to actual dimensions at rendering
**/
dimensions: {
h: ComputedLength;
w: ComputedLength;
} | undefined;
/**
* @type {string}
*/
lang: string | undefined;
_registerEvent(elem: any): void;
/**
* Retrieves the range of ISD times covered by the document
*
* @returns {[number, number]} Array of two elements: min_begin_time and max_begin_time
*
*/
getMediaTimeRange(): [number, number];
/**
* Returns list of ISD begin times
*
* @returns {number[]}
*/
getMediaTimeEvents(): number[];
}
export class HeadElement {
styling: StylingElement;
layout: LayoutElement;
}
export class StylingElement {
/**
* @type {Record<string, StyleElement>}
*/
styles: Record<string, StyleElement>;
/**
* @type {Record<string, any>}
*/
initials: Record<string, any>;
}
export class StyleElement {
/**
* @type {string}
*/
id: string;
/**
* @type {Record<string, any>}
*/
styleAttrs: Record<string, any>;
/**
* @type {string[]}
*/
styleRefs: string[];
/**
* @param {Node} node
* @param {ErrorHandler} errorHandler
*/
initFromNode(node: Node, errorHandler: ErrorHandler): void;
}
export class InitialElement {
/**
* @type {Record<string, string>}
*/
styleAttrs: Record<string, string>;
/**
* @param {Node} node
*/
initFromNode(node: Node): void;
}
export class LayoutElement {
regions: {};
}
export class ContentElement {
/**
* @param {string} kind
*/
constructor(kind: string);
kind: string;
}
export class ImageElement extends ContentElement {
/**
* @param {string} src
* @param {string} type
*/
constructor(src: string, type: string);
/**
* @type {string}
*/
src: string;
/**
* @type {string}
*/
type: string;
/**
* @param {TTElement} doc
* @param {Node} parent
* @param {Node} node
* @param {string} xmllang
* @param {ErrorHandler} errorHandler
*/
initFromNode(doc: TTElement, parent: Node, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
lang: string | undefined;
}
export class IdentifiedMixin {
/**
* @param {string} id
*/
constructor(id: string);
id: string;
/**
* @param {TTElement} doc
* @param {Node} parent
* @param {Node} node
*/
initFromNode(doc: TTElement, parent: Node, node: Node): void;
}
export class LayoutMixin {
/**
* @param {string} id
*/
constructor(id: string);
regionID: string;
/**
* @param {TTElement} doc
* @param {Node} parent
* @param {Node} node
*/
initFromNode(doc: TTElement, parent: Node, node: Node): void;
}
export class StyledMixin {
/**
* @param {Record<string, any>} styleAttrs
*/
constructor(styleAttrs: Record<string, any>);
styleAttrs: Record<string, any>;
/**
* @param {TTElement} doc
* @param {Node} parent
* @param {Node} node
* @param {ErrorHandler} errorHandler
*/
initFromNode(doc: TTElement, parent: Node, node: Node, errorHandler: ErrorHandler): void;
}
export class AnimatedMixin {
/**
* @param {any[]} sets
*/
constructor(sets: any[]);
sets: any[];
initFromNode(): void;
}
export class ContainerMixin {
/**
* @param {string} contents
*/
constructor(contents: string);
contents: string;
initFromNode(): void;
}
export class TimedMixin {
/**
*
* @param {number} explicit_begin
* @param {number} explicit_end
* @param {number} explicit_dur
*/
constructor(explicit_begin: number, explicit_end: number, explicit_dur: number);
explicit_begin: number;
explicit_end: number;
explicit_dur: number;
/**
* @param {TTElement} doc
* @param {Node} parent
* @param {Node} node
* @param {ErrorHandler} errorHandler
*/
initFromNode(doc: TTElement, parent: Node, node: Node, errorHandler: ErrorHandler): void;
timeContainer: string | undefined;
}
export class BodyElement extends ContentElement {
constructor();
/**
* @param {TTElement} doc
* @param {Node} node
* @param {string} xmllang
* @param {ErrorHandler} errorHandler
*/
initFromNode(doc: TTElement, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
lang: string | undefined;
}
export class DivElement extends ContentElement {
constructor();
/**
* @param {TTElement} doc
* @param {Node} parent
* @param {Node} node
* @param {string} xmllang
* @param {ErrorHandler} errorHandler
*/
initFromNode(doc: TTElement, parent: Node, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
lang: string | undefined;
}
export class PElement extends ContentElement {
constructor();
/**
* @param {TTElement} doc
* @param {Node} parent
* @param {Node} node
* @param {string} xmllang
* @param {ErrorHandler} errorHandler
*/
initFromNode(doc: TTElement, parent: Node, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
lang: string | undefined;
}
export class SpanElement extends ContentElement {
constructor();
/**
* @param {TTElement} doc
* @param {Node} parent
* @param {Node} node
* @param {string} xmllang
* @param {string} xmlspace
* @param {ErrorHandler} errorHandler
*/
initFromNode(doc: TTElement, parent: Node, node: Node, xmllang: string, xmlspace: string, errorHandler: ErrorHandler): void;
space: string | undefined;
lang: string | undefined;
}
export class AnonymousSpanElement extends ContentElement {
constructor();
/**
* @param {TTElement} doc
* @param {Node} parent
* @param {string} text
* @param {string} xmlspace
* @param {string} xmllang
* @param {ErrorHandler} errorHandler
*/
initFromText(doc: TTElement, parent: Node, text: string, xmllang: string, xmlspace: string, errorHandler: ErrorHandler): void;
text: string | undefined;
space: string | undefined;
lang: string | undefined;
}
export class BrElement extends ContentElement {
constructor();
/**
* @param {TTElement} doc
* @param {Node} parent
* @param {Node} node
* @param {string} xmllang
* @param {ErrorHandler} errorHandler
*/
initFromNode(doc: TTElement, parent: Node, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
lang: string | undefined;
}
export class RegionElement {
/**
* @param {string} xmllang
* @returns {RegionElement}
*/
createDefaultRegion(xmllang: string): RegionElement;
lang: string | undefined;
/**
* @param {TTElement} doc
* @param {Node} node
* @param {string} xmllang
* @param {ErrorHandler} errorHandler
*/
initFromNode(doc: TTElement, node: Node, xmllang: string, errorHandler: ErrorHandler): void;
styleAttrs: Record<string, any> | undefined;
styleRefs: string[] | undefined;
}
export class SetElement {
/**
* @param {TTElement} doc
* @param {Node} parent
* @param {Node} node
* @param {ErrorHandler} errorHandler
*/
initFromNode(doc: TTElement, parent: Node, node: Node, errorHandler: ErrorHandler): void;
styles: Record<string, any> | undefined;
}
export type ErrorHandler = import("./error").ErrorHandler;
export type Node = import("./parser").Node;
export type Parser = import("./parser").Parser;
/**
* Allows a client to provide callbacks to handle children of the <metadata> element
*/
export type MetadataHandler = {
onOpenTag: OpenTagCallBack | null;
onCloseTag: CloseTagCallBack | null;
onText: TextCallBack | null;
};
/**
* Called when the opening tag of an element node is encountered.
*/
export type OpenTagCallBack = (ns: string, name: string, attributes: Record<string, {
uri: string;
name: string;
value: string;
}>) => any;
/**
* Called when the closing tag of an element node is encountered.
*/
export type CloseTagCallBack = () => any;
/**
* Called when a text node is encountered.
*/
export type TextCallBack = (contents: string) => any;
/**
* Binary search utility function
*/
export type BinarySearchResult = {
/**
* Was an exact match found?
*/
found: boolean;
/**
* Position of the exact match or insert position
*/
index: number;
};
import { ComputedLength } from "./utils.js";
//# sourceMappingURL=doc.d.ts.map