781 lines
34 KiB
JavaScript
781 lines
34 KiB
JavaScript
var BCLSVJS = (function (window, document, docData, hljs) {
|
|
'use strict';
|
|
var title = document.getElementsByTagName('title')[0],
|
|
// data structures
|
|
classes = {thisClass: [], parentClass: []},
|
|
doc_class,
|
|
docsPath = 'https://github.com/videojs/video.js/blob/master/src/js/',
|
|
doc_data = {},
|
|
// doc path as an array
|
|
path = document.location.pathname.split('/'),
|
|
// paths
|
|
classFilePath,
|
|
parentClassFilePath,
|
|
// elements
|
|
mainContent,
|
|
main,
|
|
doc_body = document.getElementsByTagName('body')[0],
|
|
// functions
|
|
isDefined,
|
|
isItemInArray,
|
|
copyObj,
|
|
findObjectInArray,
|
|
findObjectsInArray,
|
|
getSubArray,
|
|
sortArray,
|
|
createEl,
|
|
bclslog,
|
|
findClassObjects,
|
|
addHeaderContent,
|
|
addIndex,
|
|
addMembersContent,
|
|
addText,
|
|
highlightCode,
|
|
init;
|
|
/**
|
|
* Logging function - safe for IE
|
|
*
|
|
* @param {string} context - description of the data
|
|
* @param {*} message - the data to be logged by the console
|
|
*/
|
|
bclslog = function (context, message) {
|
|
if (window['console'] && console['log']) {
|
|
console.log(context, message);
|
|
}
|
|
};
|
|
/**
|
|
* tests for all the ways a variable might be undefined or not have a value
|
|
*
|
|
* @param {*} x the variable to test
|
|
* @return {Boolean} true if variable is defined and has a value
|
|
*/
|
|
isDefined = function (x) {
|
|
if (x === '' || x === null || x === undefined || x === NaN) {
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
/**
|
|
* determines whether specified item is in an array
|
|
*
|
|
* @param {array} array to check
|
|
* @param {string} item to check for
|
|
* @return {boolean} true if item is in the array, else false
|
|
*/
|
|
isItemInArray = function (arr, item) {
|
|
var i,
|
|
iMax = arr.length;
|
|
for (i = 0; i < iMax; i++) {
|
|
if (arr[i] === item) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
/**
|
|
* get a copy of (rather than reference to) an object
|
|
*
|
|
* @param {object} obj - the object you want a copy
|
|
* @return {object} the copy
|
|
*/
|
|
copyObj = function (obj) {
|
|
if (isDefined(obj)) {
|
|
return JSON.parse(JSON.stringify(obj));
|
|
}
|
|
bclslog('no obj passed');
|
|
};
|
|
/**
|
|
* find index of an object in array of objects
|
|
* based on some property value
|
|
* generally useful for finding a unique object
|
|
*
|
|
* @param {array} targetArray - array to search
|
|
* @param {string} objProperty - object property to search
|
|
* @param {string|number} value - value of the property to search for
|
|
* @return {integer} index of first instance if found, otherwise returns -1
|
|
*/
|
|
findObjectInArray = function (targetArray, objProperty, value) {
|
|
var i, totalItems = targetArray.length, objFound = false;
|
|
for (i = 0; i < totalItems; i++) {
|
|
if (targetArray[i][objProperty] === value) {
|
|
objFound = true;
|
|
return i;
|
|
}
|
|
}
|
|
if (objFound === false) {
|
|
return -1;
|
|
}
|
|
};
|
|
/**
|
|
* find indexes of a set of object in array of objects
|
|
* based on some property value
|
|
* generally useful for finding several objects
|
|
*
|
|
* @param {array} targetArray - array to search
|
|
* @param {string} objProperty - object property to search
|
|
* @param {string|number} value - value of the property to search for
|
|
* @return {array} array of indexes for matching objects
|
|
*/
|
|
findObjectsInArray = function (targetArray, objProperty, value) {
|
|
var i, totalItems = targetArray.length, newArr = [];
|
|
for (i = 0; i < totalItems; i++) {
|
|
if (targetArray[i][objProperty] === value) {
|
|
newArr.push(i);
|
|
}
|
|
}
|
|
return newArr;
|
|
};
|
|
/**
|
|
* get a subset of objects in array of objects
|
|
* based on some property value
|
|
*
|
|
* @param {array} targetArray - array to search
|
|
* @param {string} objProperty - object property to search
|
|
* @param {string|number} value - value of the property to search for
|
|
* @return {array} array of objects with matching property value
|
|
*/
|
|
getSubArray = function (targetArray, objProperty, value) {
|
|
var i, totalItems = targetArray.length, idxArr = [];
|
|
for (i = 0; i < totalItems; i++) {
|
|
if (targetArray[i][objProperty] === value) {
|
|
idxArr.push(targetArray[i]);
|
|
}
|
|
}
|
|
return idxArr;
|
|
};
|
|
/**
|
|
* sort an array of objects based on an object property
|
|
*
|
|
* @param {array} targetArray - array to sort
|
|
* @param {string} objProperty - property whose value to sort on
|
|
* @return {array} the sorted array
|
|
*/
|
|
sortArray = function (targetArray, objProperty) {
|
|
targetArray.sort(function (a, b) {
|
|
var propA = a[objProperty].toLowerCase(), propB = b[objProperty].toLowerCase();
|
|
// sort ascending; reverse propA and propB to sort descending
|
|
if (propA < propB) {
|
|
return -1;
|
|
} else if (propA > propB) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
});
|
|
return targetArray;
|
|
};
|
|
/**
|
|
* create an element
|
|
*
|
|
* @param {string} type - the element type
|
|
* @param {object} attributes - attributes to add to the element
|
|
* @return {object} the HTML element
|
|
*/
|
|
createEl = function (type, attributes) {
|
|
var el;
|
|
if (isDefined(type)) {
|
|
el = document.createElement(type);
|
|
if (isDefined(attributes)) {
|
|
var attr;
|
|
for (attr in attributes) {
|
|
el.setAttribute(attr, attributes[attr]);
|
|
}
|
|
}
|
|
return el;
|
|
}
|
|
};
|
|
/**
|
|
* creates a text node and adds it to an element
|
|
* @param {object|node} el - the node (element) to add the text to
|
|
* @param {string} str - the text to add
|
|
*/
|
|
addText = function (el, str) {
|
|
var text = document.createTextNode(str);
|
|
el.appendChild(text);
|
|
};
|
|
/**
|
|
* finds the objects in the doc data for a fileName
|
|
*
|
|
* @param {array} arr - the array of objects to search
|
|
* @param {string} filename - the filename to look for in the meta object
|
|
* @return {array} - array of the objects found
|
|
*/
|
|
findClassObjects = function (arr, filename) {
|
|
var i, totalItems = arr.length, newArr = [];
|
|
for (i = 0; i < totalItems; i++) {
|
|
if (isDefined(arr[i].meta)) {
|
|
if (arr[i].meta.filename === filename) {
|
|
newArr.push(arr[i]);
|
|
}
|
|
}
|
|
|
|
}
|
|
return newArr;
|
|
|
|
};
|
|
/**
|
|
* add the class header content
|
|
*/
|
|
addHeaderContent = function () {
|
|
var topSection = createEl('section', {id: 'top', class: 'section'}),
|
|
headerData = doc_data.thisClass.headerInfo,
|
|
header = createEl('h1'),
|
|
extendsNode = createEl('p'),
|
|
extendsLink,
|
|
definedIn = createEl('p'),
|
|
definedInLink = createEl('a', {href: docsPath + classFilePath + '#L' + headerData.meta.lineno}),
|
|
description = createEl('div', {style: 'border:none', id: 'classDescription'}),
|
|
descriptionEl,
|
|
constructorHeader = createEl('h3'),
|
|
constructorPre = createEl('pre'),
|
|
constructorCode = createEl('code'),
|
|
constructorParamsHeader = createEl('h4'),
|
|
constructorParams = [],
|
|
text;
|
|
// add main content wrapper
|
|
doc_body.appendChild(mainContent);
|
|
main = document.getElementById('main');
|
|
// add elements
|
|
topSection.appendChild(header);
|
|
topSection.appendChild(description);
|
|
// source file
|
|
topSection.appendChild(definedIn);
|
|
addText(definedIn, 'DEFINED IN: ');
|
|
definedIn.appendChild(definedInLink);
|
|
addText(definedInLink, headerData.meta.filename + ' line number: ' + headerData.meta.lineno);
|
|
mainContent.appendChild(topSection);
|
|
// page header
|
|
addText(header, headerData.name);
|
|
// parent info if this class extends another
|
|
if (isDefined(doc_data.parentClasses)) {
|
|
topSection.appendChild(extendsNode);
|
|
addText(extendsNode, 'EXTENDS: ');
|
|
extendsLink = createEl('a', {href: parentClassFilePath + doc_data.parentClasses[0].headerInfo.meta.filename});
|
|
extendsNode.appendChild(extendsLink);
|
|
addText(extendsLink, doc_data.parentClasses[0].headerInfo.meta.filename);
|
|
}
|
|
// constructor info - don't add for video.js
|
|
if (doc_data.thisClass.headerInfo.name !== 'videojs') {
|
|
topSection.appendChild(constructorHeader);
|
|
topSection.appendChild(constructorPre);
|
|
constructorPre.appendChild(constructorCode);
|
|
// create the constructor info
|
|
addText(constructorHeader, 'Constructor');
|
|
|
|
// get constructor params if any
|
|
if (isDefined(headerData.params)) {
|
|
var paramTableHeaders = ['name', 'Type', 'Required', 'Description'],
|
|
paramTable = createEl('table'),
|
|
paramThead = createEl('thead'),
|
|
paramTbody = createEl('tbody'),
|
|
paramTheadRow = createEl('tr'),
|
|
paramTbodyRow = createEl('tr'),
|
|
paramTH,
|
|
paramTD,
|
|
k,
|
|
kMax;
|
|
|
|
addText(constructorParamsHeader, 'Parameters');
|
|
paramTable.appendChild(paramThead);
|
|
paramTable.appendChild(paramTbody);
|
|
paramThead.appendChild(paramTheadRow);
|
|
// set the table headers
|
|
kMax = paramTableHeaders.length;
|
|
for (k = 0; k < kMax; k++) {
|
|
paramTH = createEl('th');
|
|
paramTheadRow.appendChild(paramTH);
|
|
addText(paramTH, paramTableHeaders[k]);
|
|
}
|
|
// now the table info
|
|
kMax = headerData.params.length;
|
|
for (k = 0; k < kMax; k++) {
|
|
paramTbodyRow = createEl('tr');
|
|
paramTbody.appendChild(paramTbodyRow);
|
|
paramTD = createEl('td');
|
|
addText(paramTD, headerData.params[k].name);
|
|
paramTbodyRow.appendChild(paramTD);
|
|
paramTD = createEl('td');
|
|
addText(paramTD, headerData.params[k].type.names.join('|'));
|
|
paramTbodyRow.appendChild(paramTD);
|
|
paramTD = createEl('td');
|
|
if (headerData.params[k].optional) {
|
|
text = document.createTextNode('no');
|
|
constructorParams.push('[' + headerData.params[k].name + ']');
|
|
} else {
|
|
text = document.createTextNode('yes');
|
|
constructorParams.push(headerData.params[k].name);
|
|
}
|
|
paramTD.appendChild(text);
|
|
if (isDefined(headerData.params[k].description)) {
|
|
paramTbodyRow.appendChild(paramTD);
|
|
paramTD = createEl('td');
|
|
addText(paramTD, headerData.params[k].description.slice(3, headerData.params[k].description.indexOf('</p>')));
|
|
paramTbodyRow.appendChild(paramTD);
|
|
}
|
|
paramTbody.appendChild(paramTbodyRow);
|
|
}
|
|
topSection.appendChild(constructorParamsHeader);
|
|
topSection.appendChild(paramTable);
|
|
}
|
|
}
|
|
// add constructor params to signature if any
|
|
if (constructorParams.length > 0) {
|
|
text = document.createTextNode(headerData.name + '( ' + constructorParams.join(',') + ' )');
|
|
} else {
|
|
text = document.createTextNode(headerData.name + '()');
|
|
}
|
|
constructorCode.appendChild(text);
|
|
descriptionEl = document.getElementById('classDescription');
|
|
descriptionEl.innerHTML = headerData.description;
|
|
};
|
|
/**
|
|
* add the side nav
|
|
*/
|
|
addIndex = function () {
|
|
var section = createEl('section', {id: 'index', class: 'side-nav'}),
|
|
navHeader = createEl('h2', {class: 'sideNavHeader'}),
|
|
navHeaderLink = createEl('a', {href: 'index.html'}),
|
|
memberIndex = createEl('div', {id: 'memberIndex', class: 'member-index'}),
|
|
thisMember,
|
|
addedMembers = {},
|
|
item,
|
|
thisParent,
|
|
parentList,
|
|
header,
|
|
listItem,
|
|
listLink,
|
|
classHeader,
|
|
parentHeader,
|
|
i,
|
|
iMax,
|
|
j,
|
|
jMax,
|
|
// helper functions
|
|
classHasMembers = function (member) {
|
|
if (doc_data.thisClass[member].length > 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
parentsHaveMembers = function () {
|
|
if (doc_data.parentClasses.length > 0) {
|
|
for (i = 0; i < doc_data.parentClasses.length; i++) {
|
|
if (doc_data.parentClasses[i][thisMember].length > 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
},
|
|
makeList = function (classArr, parentArr, member, list) {
|
|
thisMember = member.toLowerCase();
|
|
if (classArr.length > 0 || (isDefined(doc_data.parentClass) && parentArr.length > 0)) {
|
|
// add member list header
|
|
if (classHasMembers(thisMember) || parentsHaveMembers(thisMember)) {
|
|
header = createEl('h3');
|
|
addText(header, doc_data.thisClass.headerInfo.name + ' ' + member);
|
|
} else {
|
|
return;
|
|
}
|
|
if (classHasMembers(thisMember)) {
|
|
classHeader = createEl('h4');
|
|
addText(classHeader, 'Class ' + member);
|
|
memberIndex.appendChild(header);
|
|
memberIndex.appendChild(classHeader);
|
|
// add the list & items
|
|
list = createEl('ul', {id: list});
|
|
memberIndex.appendChild(list);
|
|
iMax = classArr.length;
|
|
for (i = 0; i < iMax; i++) {
|
|
item = classArr[i].name;
|
|
if (!isItemInArray(addedMembers[member], item)) {
|
|
// keep track of added members to remove overridden ones
|
|
addedMembers[member].push(item);
|
|
listItem = createEl('li');
|
|
listLink = createEl('a', {href: '#' + member + item});
|
|
addText(listLink, item);
|
|
listItem.appendChild(listLink);
|
|
list.appendChild(listItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
// add inherited items if any
|
|
if (isDefined(parentArr) && parentArr.length > 0) {
|
|
jMax = parentArr.length;
|
|
for (j = 0; j < jMax; j++) {
|
|
thisParent = parentArr[j];
|
|
if (thisParent[thisMember].length > 0) {
|
|
parentHeader = createEl('h4');
|
|
addText(parentHeader, 'Inherited ' + member + ' from ' + thisParent.headerInfo.name);
|
|
memberIndex.appendChild(parentHeader);
|
|
parentList = createEl('ul');
|
|
memberIndex.appendChild(parentList);
|
|
iMax = thisParent[thisMember].length;
|
|
for (i = 0; i < iMax; i++) {
|
|
item = thisParent[thisMember][i].name;
|
|
if (!isItemInArray(addedMembers[member], item)) {
|
|
addedMembers[member].push(item);
|
|
listItem = createEl('li');
|
|
listLink = createEl('a', {href: '#' + member + item});
|
|
listItem.appendChild(listLink);
|
|
addText(listLink, item);
|
|
parentList.appendChild(listItem);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
};
|
|
// data structure to track members already added
|
|
addedMembers.Methods = [];
|
|
addedMembers.Properties = [];
|
|
addedMembers.Events = [];
|
|
|
|
navHeader.appendChild(navHeaderLink);
|
|
addText(navHeaderLink, 'API Index');
|
|
// add parent class members if any
|
|
if (isDefined(doc_data.parentClasses)) {
|
|
makeList(doc_data.thisClass.properties, doc_data.parentClasses, 'Properties', 'propertiesList');
|
|
makeList(doc_data.thisClass.methods, doc_data.parentClasses, 'Methods', 'methodsList');
|
|
makeList(doc_data.thisClass.events, doc_data.parentClasses, 'Events', 'eventsList');
|
|
} else {
|
|
makeList(doc_data.thisClass.properties, [], 'Properties', 'propertiesList');
|
|
makeList(doc_data.thisClass.methods, [], 'Methods', 'methodsList');
|
|
makeList(doc_data.thisClass.events, [], 'Events', 'eventsList');
|
|
}
|
|
section.appendChild(navHeader);
|
|
section.appendChild(memberIndex);
|
|
doc_body.appendChild(section);
|
|
|
|
};
|
|
/**
|
|
* add the member content
|
|
*/
|
|
addMembersContent = function () {
|
|
var members = [{name: 'Properties', data: 'properties'}, {name: 'Methods', data: 'methods'}, {name: 'Events', data: 'events'}],
|
|
member,
|
|
addedMembers = {},
|
|
section,
|
|
header,
|
|
headerSuffix,
|
|
item,
|
|
itemWrapper,
|
|
itemHeader,
|
|
itemHeaderStr,
|
|
itemParams = [],
|
|
itemParamsHeader,
|
|
itemDescription,
|
|
itemDescriptionEl,
|
|
itemFooter,
|
|
itemFooterLink,
|
|
itemFooterContent,
|
|
paramTable,
|
|
paramThead,
|
|
paramTbody,
|
|
paramTheadRow,
|
|
paramTbodyRow,
|
|
paramTH,
|
|
paramTD,
|
|
paramTableHeaders = ['name', 'Type', 'Required', 'Description'],
|
|
text,
|
|
i,
|
|
iMax,
|
|
j,
|
|
jMax,
|
|
k,
|
|
kMax,
|
|
m,
|
|
mMax,
|
|
topLinkP,
|
|
topLinkA,
|
|
// helper function
|
|
createMemberItem = function (classData, member) {
|
|
bclslog('member', member);
|
|
// create the class member items
|
|
jMax = classData[member.data].length;
|
|
for (j = 0; j < jMax; j++) {
|
|
item = classData[member.data][j];
|
|
if (!isItemInArray(addedMembers[member.name], item.name)) {
|
|
addedMembers[member.name].push(item.name);
|
|
itemWrapper = createEl('div', {id: member.name + item.name});
|
|
section.appendChild(itemWrapper);
|
|
itemHeader = createEl('h3', {id: item.name + 'Header'});
|
|
itemHeaderStr = item.name;
|
|
itemWrapper.appendChild(itemHeader);
|
|
itemDescription = createEl('div', {id: item.name + 'Description', class: 'description'});
|
|
itemWrapper.appendChild(itemDescription);
|
|
itemFooter = createEl('p', {class: 'vjs-only'});
|
|
itemFooterLink = createEl('a', {href: docsPath + item.meta.filename + '#L' + item.meta.lineno});
|
|
itemFooterContent = createEl('em', {id: item.name + 'Footer'});
|
|
itemFooter.appendChild(itemFooterContent);
|
|
topLinkP = createEl('p');
|
|
topLinkA = createEl('a', {href: '#top'});
|
|
addText(topLinkA, '[back to top]');
|
|
topLinkP.appendChild(topLinkA);
|
|
// for methods only handle params if any
|
|
if (member.name === 'Methods' && isDefined(item.params)) {
|
|
itemParams = [];
|
|
itemParamsHeader = createEl('h4');
|
|
addText(itemParamsHeader, 'Parameters');
|
|
paramTable = createEl('table');
|
|
paramThead = createEl('thead');
|
|
paramTbody = createEl('tbody');
|
|
paramTable.appendChild(paramThead);
|
|
paramTable.appendChild(paramTbody);
|
|
paramTheadRow = createEl('tr');
|
|
paramThead.appendChild(paramTheadRow);
|
|
// set the table headers
|
|
kMax = paramTableHeaders.length;
|
|
for (k = 0; k < kMax; k++) {
|
|
paramTH = createEl('th');
|
|
paramTheadRow.appendChild(paramTH);
|
|
addText(paramTH, paramTableHeaders[k]);
|
|
}
|
|
// now the table info
|
|
kMax = item.params.length;
|
|
for (k = 0; k < kMax; k++) {
|
|
paramTbodyRow = createEl('tr');
|
|
paramTbody.appendChild(paramTbodyRow);
|
|
paramTD = createEl('td');
|
|
addText(paramTD, item.params[k].name);
|
|
paramTbodyRow.appendChild(paramTD);
|
|
paramTD = createEl('td');
|
|
addText(paramTD, item.params[k].type.names.join('|'));
|
|
paramTbodyRow.appendChild(paramTD);
|
|
paramTD = createEl('td');
|
|
if (item.params[k].optional) {
|
|
text = document.createTextNode('no');
|
|
itemParams.push('[' + item.params[k].name + ']');
|
|
} else {
|
|
text = document.createTextNode('yes');
|
|
itemParams.push(item.params[k].name);
|
|
}
|
|
paramTD.appendChild(text);
|
|
if (isDefined(item.params[k].description)) {
|
|
paramTbodyRow.appendChild(paramTD);
|
|
paramTD = createEl('td');
|
|
addText(paramTD, item.params[k].description.slice(3, item.params[k].description.indexOf('</p>')));
|
|
paramTbodyRow.appendChild(paramTD);
|
|
}
|
|
paramTbody.appendChild(paramTbodyRow);
|
|
}
|
|
itemHeaderStr += '( ' + itemParams.join(', ') + ' )';
|
|
if (item.scope === 'static') {
|
|
itemHeaderStr = 'static ' + itemHeaderStr;
|
|
}
|
|
itemWrapper.appendChild(itemParamsHeader);
|
|
itemWrapper.appendChild(paramTable);
|
|
} else if (member.name === 'Methods') {
|
|
itemHeaderStr += '()';
|
|
}
|
|
itemWrapper.appendChild(itemFooter);
|
|
itemWrapper.appendChild(topLinkP);
|
|
addText(itemHeader, itemHeaderStr);
|
|
if (isDefined(item.deprecated)) {
|
|
headerSuffix = createEl('em', {class: 'deprecated'});
|
|
text = document.createTextNode();
|
|
addText(headerSuffix, ' (deprecated)');
|
|
itemHeader.appendChild(headerSuffix);
|
|
}
|
|
itemDescriptionEl = document.getElementById(item.name + 'Description');
|
|
itemDescriptionEl.innerHTML = item.description;
|
|
addText(itemFooterContent, 'Defined in ');
|
|
itemFooterContent.appendChild(itemFooterLink);
|
|
addText(itemFooterLink, 'src/js/' + item.meta.filename + ' line number: ' + item.meta.lineno);
|
|
}
|
|
}
|
|
};
|
|
// data structure to track members already added
|
|
addedMembers.Methods = [];
|
|
addedMembers.Properties = [];
|
|
addedMembers.Events = [];
|
|
iMax = members.length;
|
|
for (i = 0; i < iMax; i++) {
|
|
member = members[i];
|
|
if (doc_data.thisClass[member.data].length > 0) {
|
|
// create the member section
|
|
section = createEl('section', {id: member.name.toLowerCase(), class: 'section'});
|
|
main.appendChild(section);
|
|
header = createEl('h2');
|
|
addText(header, member.name);
|
|
section.appendChild(header);
|
|
// create the member items
|
|
createMemberItem(doc_data.thisClass, member);
|
|
if (isDefined(doc_data.parentClasses)) {
|
|
mMax = doc_data.parentClasses.length;
|
|
for (m = 0; m < mMax; m++) {
|
|
if (doc_data.parentClasses[m][member.data].length > 0) {
|
|
createMemberItem(doc_data.parentClasses[m], member);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* use hljs to highlight the syntax in code blocks
|
|
*/
|
|
highlightCode = function () {
|
|
var codeBlocks = document.querySelectorAll('pre code'),
|
|
i,
|
|
iMax;
|
|
if (isDefined(codeBlocks)) {
|
|
iMax = codeBlocks.length;
|
|
for (i = 0; i < iMax; i++) {
|
|
hljs.highlightBlock(codeBlocks[i]);
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* init gets things going
|
|
*/
|
|
init = function () {
|
|
var fileName,
|
|
srcFileName,
|
|
parent_class_name,
|
|
privateItems = [],
|
|
idx,
|
|
text,
|
|
j,
|
|
parentCounter = 0,
|
|
// helper function to get the chain of parent classes
|
|
getAncestorData = function (parent_class) {
|
|
// get data objects for the class
|
|
classes.parentClasses[parentCounter] = findClassObjects(docData, parent_class + '.js');
|
|
// check to see if there are any parent class items
|
|
if (classes.parentClasses[parentCounter].length > 0) {
|
|
doc_data.parentClasses[parentCounter] = {};
|
|
// get parent header info
|
|
idx = findObjectInArray(classes.parentClasses[parentCounter], 'kind', 'class');
|
|
doc_data.parentClasses[parentCounter].headerInfo = copyObj(classes.parentClasses[parentCounter][idx]);
|
|
// get parent class path
|
|
idx = findObjectInArray(classes.parentClasses[parentCounter], 'kind', 'file');
|
|
if (idx > -1) {
|
|
parentClassFilePath = classes.parentClasses[parentCounter][idx].name;
|
|
} else {
|
|
parentClassFilePath = doc_data.parentClasses[parentCounter].headerInfo.meta.filename;
|
|
}
|
|
// remove any private items
|
|
privateItems = findObjectsInArray(classes.parentClasses[parentCounter], 'access', 'private');
|
|
j = privateItems.length;
|
|
while (j > 0) {
|
|
j--;
|
|
classes.parentClasses[parentCounter].splice(privateItems[j], 1);
|
|
}
|
|
// now get the member arrays
|
|
doc_data.parentClasses[parentCounter].methods = getSubArray(classes.parentClasses[parentCounter], 'kind', 'function');
|
|
doc_data.parentClasses[parentCounter].methods = sortArray(doc_data.parentClasses[parentCounter].methods, 'name');
|
|
doc_data.parentClasses[parentCounter].events = getSubArray(classes.parentClasses[parentCounter], 'kind', 'event');
|
|
doc_data.parentClasses[parentCounter].events = sortArray(doc_data.parentClasses[parentCounter].events, 'name');
|
|
doc_data.parentClasses[parentCounter].properties = getSubArray(classes.parentClasses[parentCounter], 'kind', 'property');
|
|
doc_data.parentClasses[parentCounter].properties = sortArray(doc_data.parentClasses[parentCounter].properties, 'name');
|
|
}
|
|
// get parent class, if any, and anything it inherits
|
|
if (isDefined(doc_data.parentClasses[parentCounter].headerInfo.augments)) {
|
|
idx = findObjectInArray(docData, 'name', doc_data.parentClasses[parentCounter].headerInfo.augments[0]);
|
|
parent_class_name = docData[idx].meta.filename.replace('.js', '');
|
|
parentCounter++;
|
|
getAncestorData(parent_class_name);
|
|
}
|
|
};
|
|
// content wrapper
|
|
mainContent = createEl('div', {id: 'main', class: 'section'});
|
|
// get the class name from the file name
|
|
fileName = path[path.length - 1];
|
|
doc_class = fileName.substring(0, fileName.indexOf('.'));
|
|
srcFileName = doc_class + '.js';
|
|
bclslog('srcFileName', srcFileName);
|
|
// video.js is a special case - all others will be the same
|
|
if (srcFileName === 'video.js') {
|
|
// for doc purposes, treat video like a class, though it's not
|
|
// get the data objects for this class
|
|
classes.thisClass = findClassObjects(docData, srcFileName);
|
|
bclslog('classes', classes);
|
|
idx = findObjectInArray(classes.thisClass, 'name', 'videojs');
|
|
doc_data.thisClass = {};
|
|
// get the class overview object
|
|
doc_data.thisClass.headerInfo = copyObj(classes.thisClass[idx]);
|
|
doc_data.thisClass.headerInfo.name = 'videojs';
|
|
idx = findObjectInArray(classes.thisClass, 'kind', 'file');
|
|
if (idx > -1) {
|
|
classFilePath = classes.thisClass[idx].name;
|
|
} else {
|
|
classFilePath = doc_data.thisClass.headerInfo.meta.filename;
|
|
}
|
|
// set the doc title
|
|
text = document.createTextNode(doc_data.thisClass.headerInfo.name);
|
|
title.appendChild(text);
|
|
// remove any private items
|
|
privateItems = findObjectsInArray(classes.thisClass, 'access', 'private');
|
|
j = privateItems.length;
|
|
while (j > 0) {
|
|
j--;
|
|
classes.thisClass.splice(privateItems[j], 1);
|
|
}
|
|
// now get the member arrays
|
|
doc_data.thisClass.methods = getSubArray(classes.thisClass, 'kind', 'function');
|
|
doc_data.thisClass.methods = sortArray(doc_data.thisClass.methods, 'name');
|
|
doc_data.thisClass.events = getSubArray(classes.thisClass, 'kind', 'event');
|
|
doc_data.thisClass.events = sortArray(doc_data.thisClass.events, 'name');
|
|
doc_data.thisClass.properties = getSubArray(classes.thisClass, 'kind', 'property');
|
|
doc_data.thisClass.properties = sortArray(doc_data.thisClass.properties, 'name');
|
|
bclslog('thisClass', doc_data.thisClass);
|
|
} else {
|
|
// get the data objects for this class
|
|
classes.thisClass = findClassObjects(docData, srcFileName);
|
|
bclslog('classes', classes);
|
|
idx = findObjectInArray(classes.thisClass, 'kind', 'class');
|
|
doc_data.thisClass = {};
|
|
doc_data.thisClass.headerInfo = copyObj(classes.thisClass[idx]);
|
|
// get the file path from @file object
|
|
idx = findObjectInArray(classes.thisClass, 'kind', 'file');
|
|
if (idx > -1) {
|
|
classFilePath = classes.thisClass[idx].name;
|
|
} else {
|
|
classFilePath = doc_data.thisClass.headerInfo.meta.filename;
|
|
}
|
|
// set the doc title
|
|
text = document.createTextNode(doc_data.thisClass.headerInfo.name);
|
|
title.appendChild(text);
|
|
// remove any private items
|
|
privateItems = findObjectsInArray(classes.thisClass, 'access', 'private');
|
|
j = privateItems.length;
|
|
while (j > 0) {
|
|
j--;
|
|
classes.thisClass.splice(privateItems[j], 1);
|
|
}
|
|
// now get the member arrays
|
|
doc_data.thisClass.methods = getSubArray(classes.thisClass, 'kind', 'function');
|
|
doc_data.thisClass.methods = sortArray(doc_data.thisClass.methods, 'name');
|
|
doc_data.thisClass.events = getSubArray(classes.thisClass, 'kind', 'event');
|
|
doc_data.thisClass.events = sortArray(doc_data.thisClass.events, 'name');
|
|
doc_data.thisClass.properties = getSubArray(classes.thisClass, 'kind', 'property');
|
|
doc_data.thisClass.properties = sortArray(doc_data.thisClass.properties, 'name');
|
|
bclslog('thisClass', doc_data.thisClass);
|
|
// get parent class, if any, and anything it inherits
|
|
if (isDefined(doc_data.thisClass.headerInfo.augments)) {
|
|
doc_data.parentClass = {};
|
|
doc_data.parentClasses = [];
|
|
classes.parentClasses = [];
|
|
idx = findObjectInArray(docData, 'name', doc_data.thisClass.headerInfo.augments[0]);
|
|
parent_class_name = docData[idx].meta.filename.replace('.js', '');
|
|
getAncestorData(parent_class_name);
|
|
}
|
|
bclslog('parentClasses', doc_data.parentClasses);
|
|
}
|
|
// now we're ready to roll
|
|
addIndex();
|
|
addHeaderContent();
|
|
addMembersContent();
|
|
highlightCode();
|
|
};
|
|
// initialize
|
|
init();
|
|
return {
|
|
|
|
};
|
|
})(window, document, docData, hljs);
|