5876 lines
150 KiB
JavaScript
5876 lines
150 KiB
JavaScript
(function(global) {
|
|
var define, requireModule, require, requirejs;
|
|
|
|
(function() {
|
|
var registry = {}, seen = {};
|
|
|
|
define = function(name, deps, callback) {
|
|
registry[name] = { deps: deps, callback: callback };
|
|
};
|
|
|
|
requirejs = require = requireModule = function(name) {
|
|
requirejs._eak_seen = registry;
|
|
|
|
if (seen[name]) { return seen[name]; }
|
|
seen[name] = {};
|
|
|
|
if (!registry[name]) {
|
|
throw new Error("Could not find module " + name);
|
|
}
|
|
|
|
var mod = registry[name],
|
|
deps = mod.deps,
|
|
callback = mod.callback,
|
|
reified = [],
|
|
exports;
|
|
|
|
for (var i=0, l=deps.length; i<l; i++) {
|
|
if (deps[i] === 'exports') {
|
|
reified.push(exports = {});
|
|
} else {
|
|
reified.push(requireModule(resolve(deps[i])));
|
|
}
|
|
}
|
|
|
|
var value = callback.apply(this, reified);
|
|
return seen[name] = exports || value;
|
|
|
|
function resolve(child) {
|
|
if (child.charAt(0) !== '.') { return child; }
|
|
var parts = child.split("/");
|
|
var parentBase = name.split("/").slice(0, -1);
|
|
|
|
for (var i=0, l=parts.length; i<l; i++) {
|
|
var part = parts[i];
|
|
|
|
if (part === '..') { parentBase.pop(); }
|
|
else if (part === '.') { continue; }
|
|
else { parentBase.push(part); }
|
|
}
|
|
|
|
return parentBase.join("/");
|
|
}
|
|
};
|
|
})();
|
|
|
|
define("rsvp/all",
|
|
["./promise","exports"],
|
|
function(__dependency1__, __exports__) {
|
|
"use strict";
|
|
var Promise = __dependency1__["default"];
|
|
|
|
__exports__["default"] = function all(array, label) {
|
|
return Promise.all(array, label);
|
|
};
|
|
});
|
|
define("rsvp/asap",
|
|
["exports"],
|
|
function(__exports__) {
|
|
"use strict";
|
|
__exports__["default"] = function asap(callback, arg) {
|
|
var length = queue.push([callback, arg]);
|
|
if (length === 1) {
|
|
// If length is 1, that means that we need to schedule an async flush.
|
|
// If additional callbacks are queued before the queue is flushed, they
|
|
// will be processed by this flush that we are scheduling.
|
|
scheduleFlush();
|
|
}
|
|
};
|
|
|
|
var browserGlobal = (typeof window !== 'undefined') ? window : {};
|
|
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
|
|
|
|
// node
|
|
function useNextTick() {
|
|
return function() {
|
|
process.nextTick(flush);
|
|
};
|
|
}
|
|
|
|
function useMutationObserver() {
|
|
var iterations = 0;
|
|
var observer = new BrowserMutationObserver(flush);
|
|
var node = document.createTextNode('');
|
|
observer.observe(node, { characterData: true });
|
|
|
|
return function() {
|
|
node.data = (iterations = ++iterations % 2);
|
|
};
|
|
}
|
|
|
|
function useSetTimeout() {
|
|
return function() {
|
|
setTimeout(flush, 1);
|
|
};
|
|
}
|
|
|
|
var queue = [];
|
|
function flush() {
|
|
for (var i = 0; i < queue.length; i++) {
|
|
var tuple = queue[i];
|
|
var callback = tuple[0], arg = tuple[1];
|
|
callback(arg);
|
|
}
|
|
queue = [];
|
|
}
|
|
|
|
var scheduleFlush;
|
|
|
|
// Decide what async method to use to triggering processing of queued callbacks:
|
|
if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
|
|
scheduleFlush = useNextTick();
|
|
} else if (BrowserMutationObserver) {
|
|
scheduleFlush = useMutationObserver();
|
|
} else {
|
|
scheduleFlush = useSetTimeout();
|
|
}
|
|
});
|
|
define("rsvp/config",
|
|
["./events","exports"],
|
|
function(__dependency1__, __exports__) {
|
|
"use strict";
|
|
var EventTarget = __dependency1__["default"];
|
|
|
|
var config = {
|
|
instrument: false
|
|
};
|
|
|
|
EventTarget.mixin(config);
|
|
|
|
function configure(name, value) {
|
|
if (name === 'onerror') {
|
|
// handle for legacy users that expect the actual
|
|
// error to be passed to their function added via
|
|
// `RSVP.configure('onerror', someFunctionHere);`
|
|
config.on('error', value);
|
|
return;
|
|
}
|
|
|
|
if (arguments.length === 2) {
|
|
config[name] = value;
|
|
} else {
|
|
return config[name];
|
|
}
|
|
}
|
|
|
|
__exports__.config = config;
|
|
__exports__.configure = configure;
|
|
});
|
|
define("rsvp/defer",
|
|
["./promise","exports"],
|
|
function(__dependency1__, __exports__) {
|
|
"use strict";
|
|
var Promise = __dependency1__["default"];
|
|
|
|
/**
|
|
`RSVP.defer` returns an object similar to jQuery's `$.Deferred` objects.
|
|
`RSVP.defer` should be used when porting over code reliant on `$.Deferred`'s
|
|
interface. New code should use the `RSVP.Promise` constructor instead.
|
|
|
|
The object returned from `RSVP.defer` is a plain object with three properties:
|
|
|
|
* promise - an `RSVP.Promise`.
|
|
* reject - a function that causes the `promise` property on this object to
|
|
become rejected
|
|
* resolve - a function that causes the `promise` property on this object to
|
|
become fulfilled.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
var deferred = RSVP.defer();
|
|
|
|
deferred.resolve("Success!");
|
|
|
|
defered.promise.then(function(value){
|
|
// value here is "Success!"
|
|
});
|
|
```
|
|
|
|
@method defer
|
|
@for RSVP
|
|
@param {String} -
|
|
@return {Object}
|
|
*/
|
|
|
|
__exports__["default"] = function defer(label) {
|
|
var deferred = { };
|
|
|
|
deferred.promise = new Promise(function(resolve, reject) {
|
|
deferred.resolve = resolve;
|
|
deferred.reject = reject;
|
|
}, label);
|
|
|
|
return deferred;
|
|
};
|
|
});
|
|
define("rsvp/events",
|
|
["exports"],
|
|
function(__exports__) {
|
|
"use strict";
|
|
var indexOf = function(callbacks, callback) {
|
|
for (var i=0, l=callbacks.length; i<l; i++) {
|
|
if (callbacks[i] === callback) { return i; }
|
|
}
|
|
|
|
return -1;
|
|
};
|
|
|
|
var callbacksFor = function(object) {
|
|
var callbacks = object._promiseCallbacks;
|
|
|
|
if (!callbacks) {
|
|
callbacks = object._promiseCallbacks = {};
|
|
}
|
|
|
|
return callbacks;
|
|
};
|
|
|
|
/**
|
|
//@module RSVP
|
|
//@class EventTarget
|
|
*/
|
|
__exports__["default"] = {
|
|
|
|
/**
|
|
@private
|
|
`RSVP.EventTarget.mixin` extends an object with EventTarget methods. For
|
|
Example:
|
|
|
|
```javascript
|
|
var object = {};
|
|
|
|
RSVP.EventTarget.mixin(object);
|
|
|
|
object.on("finished", function(event) {
|
|
// handle event
|
|
});
|
|
|
|
object.trigger("finished", { detail: value });
|
|
```
|
|
|
|
`EventTarget.mixin` also works with prototypes:
|
|
|
|
```javascript
|
|
var Person = function() {};
|
|
RSVP.EventTarget.mixin(Person.prototype);
|
|
|
|
var yehuda = new Person();
|
|
var tom = new Person();
|
|
|
|
yehuda.on("poke", function(event) {
|
|
console.log("Yehuda says OW");
|
|
});
|
|
|
|
tom.on("poke", function(event) {
|
|
console.log("Tom says OW");
|
|
});
|
|
|
|
yehuda.trigger("poke");
|
|
tom.trigger("poke");
|
|
```
|
|
|
|
@method mixin
|
|
@param {Object} object object to extend with EventTarget methods
|
|
*/
|
|
mixin: function(object) {
|
|
object.on = this.on;
|
|
object.off = this.off;
|
|
object.trigger = this.trigger;
|
|
object._promiseCallbacks = undefined;
|
|
return object;
|
|
},
|
|
|
|
/**
|
|
@private
|
|
|
|
Registers a callback to be executed when `eventName` is triggered
|
|
|
|
```javascript
|
|
object.on('event', function(eventInfo){
|
|
// handle the event
|
|
});
|
|
|
|
object.trigger('event');
|
|
```
|
|
|
|
@method on
|
|
@param {String} eventName name of the event to listen for
|
|
@param {Function} callback function to be called when the event is triggered.
|
|
*/
|
|
on: function(eventName, callback) {
|
|
var allCallbacks = callbacksFor(this), callbacks;
|
|
|
|
callbacks = allCallbacks[eventName];
|
|
|
|
if (!callbacks) {
|
|
callbacks = allCallbacks[eventName] = [];
|
|
}
|
|
|
|
if (indexOf(callbacks, callback) === -1) {
|
|
callbacks.push(callback);
|
|
}
|
|
},
|
|
|
|
/**
|
|
@private
|
|
|
|
You can use `off` to stop firing a particular callback for an event:
|
|
|
|
```javascript
|
|
function doStuff() { // do stuff! }
|
|
object.on('stuff', doStuff);
|
|
|
|
object.trigger('stuff'); // doStuff will be called
|
|
|
|
// Unregister ONLY the doStuff callback
|
|
object.off('stuff', doStuff);
|
|
object.trigger('stuff'); // doStuff will NOT be called
|
|
```
|
|
|
|
If you don't pass a `callback` argument to `off`, ALL callbacks for the
|
|
event will not be executed when the event fires. For example:
|
|
|
|
```javascript
|
|
var callback1 = function(){};
|
|
var callback2 = function(){};
|
|
|
|
object.on('stuff', callback1);
|
|
object.on('stuff', callback2);
|
|
|
|
object.trigger('stuff'); // callback1 and callback2 will be executed.
|
|
|
|
object.off('stuff');
|
|
object.trigger('stuff'); // callback1 and callback2 will not be executed!
|
|
```
|
|
|
|
@method off
|
|
@param {String} eventName event to stop listening to
|
|
@param {Function} callback optional argument. If given, only the function
|
|
given will be removed from the event's callback queue. If no `callback`
|
|
argument is given, all callbacks will be removed from the event's callback
|
|
queue.
|
|
*/
|
|
off: function(eventName, callback) {
|
|
var allCallbacks = callbacksFor(this), callbacks, index;
|
|
|
|
if (!callback) {
|
|
allCallbacks[eventName] = [];
|
|
return;
|
|
}
|
|
|
|
callbacks = allCallbacks[eventName];
|
|
|
|
index = indexOf(callbacks, callback);
|
|
|
|
if (index !== -1) { callbacks.splice(index, 1); }
|
|
},
|
|
|
|
/**
|
|
@private
|
|
|
|
Use `trigger` to fire custom events. For example:
|
|
|
|
```javascript
|
|
object.on('foo', function(){
|
|
console.log('foo event happened!');
|
|
});
|
|
object.trigger('foo');
|
|
// 'foo event happened!' logged to the console
|
|
```
|
|
|
|
You can also pass a value as a second argument to `trigger` that will be
|
|
passed as an argument to all event listeners for the event:
|
|
|
|
```javascript
|
|
object.on('foo', function(value){
|
|
console.log(value.name);
|
|
});
|
|
|
|
object.trigger('foo', { name: 'bar' });
|
|
// 'bar' logged to the console
|
|
```
|
|
|
|
@method trigger
|
|
@param {String} eventName name of the event to be triggered
|
|
@param {Any} options optional value to be passed to any event handlers for
|
|
the given `eventName`
|
|
*/
|
|
trigger: function(eventName, options) {
|
|
var allCallbacks = callbacksFor(this),
|
|
callbacks, callbackTuple, callback, binding;
|
|
|
|
if (callbacks = allCallbacks[eventName]) {
|
|
// Don't cache the callbacks.length since it may grow
|
|
for (var i=0; i<callbacks.length; i++) {
|
|
callback = callbacks[i];
|
|
|
|
callback(options);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
});
|
|
define("rsvp/filter",
|
|
["./all","./map","./utils","exports"],
|
|
function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
|
|
"use strict";
|
|
var all = __dependency1__["default"];
|
|
var map = __dependency2__["default"];
|
|
var isFunction = __dependency3__.isFunction;
|
|
var isArray = __dependency3__.isArray;
|
|
|
|
/**
|
|
`RSVP.filter` is similar to JavaScript's native `filter` method, except that it
|
|
waits for all promises to become fulfilled before running the `filterFn` on
|
|
each item in given to `promises`. `RSVP.filterFn` returns a promise that will
|
|
become fulfilled with the result of running `filterFn` on the values the
|
|
promises become fulfilled with.
|
|
|
|
For example:
|
|
|
|
```javascript
|
|
|
|
var promise1 = RSVP.resolve(1);
|
|
var promise2 = RSVP.resolve(2);
|
|
var promise3 = RSVP.resolve(3);
|
|
|
|
var filterFn = function(item){
|
|
return item > 1;
|
|
};
|
|
|
|
RSVP.filter(promises, filterFn).then(function(result){
|
|
// result is [ 2, 3 ]
|
|
});
|
|
```
|
|
|
|
If any of the `promises` given to `RSVP.filter` are rejected, the first promise
|
|
that is rejected will be given as an argument to the returned promises's
|
|
rejection handler. For example:
|
|
|
|
```javascript
|
|
var promise1 = RSVP.resolve(1);
|
|
var promise2 = RSVP.reject(new Error("2"));
|
|
var promise3 = RSVP.reject(new Error("3"));
|
|
var promises = [ promise1, promise2, promise3 ];
|
|
|
|
var filterFn = function(item){
|
|
return item > 1;
|
|
};
|
|
|
|
RSVP.filter(promises, filterFn).then(function(array){
|
|
// Code here never runs because there are rejected promises!
|
|
}, function(reason) {
|
|
// reason.message === "2"
|
|
});
|
|
```
|
|
|
|
`RSVP.filter` will also wait for any promises returned from `filterFn`.
|
|
For instance, you may want to fetch a list of users then return a subset
|
|
of those users based on some asynchronous operation:
|
|
|
|
```javascript
|
|
|
|
var alice = { name: 'alice' };
|
|
var bob = { name: 'bob' };
|
|
var users = [ alice, bob ];
|
|
|
|
var promises = users.map(function(user){
|
|
return RSVP.resolve(user);
|
|
});
|
|
|
|
var filterFn = function(user){
|
|
// Here, Alice has permissions to create a blog post, but Bob does not.
|
|
return getPrivilegesForUser(user).then(function(privs){
|
|
return privs.can_create_blog_post === true;
|
|
});
|
|
};
|
|
RSVP.filter(promises, filterFn).then(function(users){
|
|
// true, because the server told us only Alice can create a blog post.
|
|
users.length === 1;
|
|
// false, because Alice is the only user present in `users`
|
|
users[0] === bob;
|
|
});
|
|
```
|
|
|
|
@method filter
|
|
@for RSVP
|
|
@param {Array} promises
|
|
@param {Function} filterFn - function to be called on each resolved value to
|
|
filter the final results.
|
|
@param {String} label optional string describing the promise. Useful for
|
|
tooling.
|
|
@return {Promise}
|
|
*/
|
|
function filter(promises, filterFn, label) {
|
|
if (!isArray(promises)) {
|
|
throw new TypeError('You must pass an array to filter.');
|
|
}
|
|
|
|
if (!isFunction(filterFn)){
|
|
throw new TypeError("You must pass a function to filter's second argument.");
|
|
}
|
|
|
|
return all(promises, label).then(function(values){
|
|
return map(promises, filterFn, label).then(function(filterResults){
|
|
var i,
|
|
valuesLen = values.length,
|
|
filtered = [];
|
|
|
|
for (i = 0; i < valuesLen; i++){
|
|
if(filterResults[i]) filtered.push(values[i]);
|
|
}
|
|
return filtered;
|
|
});
|
|
});
|
|
}
|
|
|
|
__exports__["default"] = filter;
|
|
});
|
|
define("rsvp/hash",
|
|
["./promise","./utils","exports"],
|
|
function(__dependency1__, __dependency2__, __exports__) {
|
|
"use strict";
|
|
var Promise = __dependency1__["default"];
|
|
var isNonThenable = __dependency2__.isNonThenable;
|
|
var keysOf = __dependency2__.keysOf;
|
|
|
|
/**
|
|
`RSVP.hash` is similar to `RSVP.all`, but takes an object instead of an array
|
|
for its `promises` argument.
|
|
|
|
Returns a promise that is fulfilled when all the given promises have been
|
|
fulfilled, or rejected if any of them become rejected. The returned promise
|
|
is fulfilled with a hash that has the same key names as the `promises` object
|
|
argument. If any of the values in the object are not promises, they will
|
|
simply be copied over to the fulfilled object.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
var promises = {
|
|
myPromise: RSVP.resolve(1),
|
|
yourPromise: RSVP.resolve(2),
|
|
theirPromise: RSVP.resolve(3),
|
|
notAPromise: 4
|
|
};
|
|
|
|
RSVP.hash(promises).then(function(hash){
|
|
// hash here is an object that looks like:
|
|
// {
|
|
// myPromise: 1,
|
|
// yourPromise: 2,
|
|
// theirPromise: 3,
|
|
// notAPromise: 4
|
|
// }
|
|
});
|
|
````
|
|
|
|
If any of the `promises` given to `RSVP.hash` are rejected, the first promise
|
|
that is rejected will be given as as the first argument, or as the reason to
|
|
the rejection handler. For example:
|
|
|
|
```javascript
|
|
var promises = {
|
|
myPromise: RSVP.resolve(1),
|
|
rejectedPromise: RSVP.reject(new Error("rejectedPromise")),
|
|
anotherRejectedPromise: RSVP.reject(new Error("anotherRejectedPromise")),
|
|
};
|
|
|
|
RSVP.hash(promises).then(function(hash){
|
|
// Code here never runs because there are rejected promises!
|
|
}, function(reason) {
|
|
// reason.message === "rejectedPromise"
|
|
});
|
|
```
|
|
|
|
An important note: `RSVP.hash` is intended for plain JavaScript objects that
|
|
are just a set of keys and values. `RSVP.hash` will NOT preserve prototype
|
|
chains.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
function MyConstructor(){
|
|
this.example = RSVP.resolve("Example");
|
|
}
|
|
|
|
MyConstructor.prototype = {
|
|
protoProperty: RSVP.resolve("Proto Property")
|
|
};
|
|
|
|
var myObject = new MyConstructor();
|
|
|
|
RSVP.hash(myObject).then(function(hash){
|
|
// protoProperty will not be present, instead you will just have an
|
|
// object that looks like:
|
|
// {
|
|
// example: "Example"
|
|
// }
|
|
//
|
|
// hash.hasOwnProperty('protoProperty'); // false
|
|
// 'undefined' === typeof hash.protoProperty
|
|
});
|
|
```
|
|
|
|
@method hash
|
|
@for RSVP
|
|
@param {Object} promises
|
|
@param {String} label - optional string that describes the promise.
|
|
Useful for tooling.
|
|
@return {Promise} promise that is fulfilled when all properties of `promises`
|
|
have been fulfilled, or rejected if any of them become rejected.
|
|
*/
|
|
__exports__["default"] = function hash(object, label) {
|
|
return new Promise(function(resolve, reject){
|
|
var results = {};
|
|
var keys = keysOf(object);
|
|
var remaining = keys.length;
|
|
var entry, property;
|
|
|
|
if (remaining === 0) {
|
|
resolve(results);
|
|
return;
|
|
}
|
|
|
|
function fulfilledTo(property) {
|
|
return function(value) {
|
|
results[property] = value;
|
|
if (--remaining === 0) {
|
|
resolve(results);
|
|
}
|
|
};
|
|
}
|
|
|
|
function onRejection(reason) {
|
|
remaining = 0;
|
|
reject(reason);
|
|
}
|
|
|
|
for (var i = 0; i < keys.length; i++) {
|
|
property = keys[i];
|
|
entry = object[property];
|
|
|
|
if (isNonThenable(entry)) {
|
|
results[property] = entry;
|
|
if (--remaining === 0) {
|
|
resolve(results);
|
|
}
|
|
} else {
|
|
Promise.cast(entry).then(fulfilledTo(property), onRejection);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
});
|
|
define("rsvp/instrument",
|
|
["./config","./utils","exports"],
|
|
function(__dependency1__, __dependency2__, __exports__) {
|
|
"use strict";
|
|
var config = __dependency1__.config;
|
|
var now = __dependency2__.now;
|
|
|
|
__exports__["default"] = function instrument(eventName, promise, child) {
|
|
// instrumentation should not disrupt normal usage.
|
|
try {
|
|
config.trigger(eventName, {
|
|
guid: promise._guidKey + promise._id,
|
|
eventName: eventName,
|
|
detail: promise._detail,
|
|
childGuid: child && promise._guidKey + child._id,
|
|
label: promise._label,
|
|
timeStamp: now(),
|
|
stack: new Error(promise._label).stack
|
|
});
|
|
} catch(error) {
|
|
setTimeout(function(){
|
|
throw error;
|
|
}, 0);
|
|
}
|
|
};
|
|
});
|
|
define("rsvp/map",
|
|
["./promise","./all","./utils","exports"],
|
|
function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
|
|
"use strict";
|
|
var Promise = __dependency1__["default"];
|
|
var all = __dependency2__["default"];
|
|
var isArray = __dependency3__.isArray;
|
|
var isFunction = __dependency3__.isFunction;
|
|
|
|
/**
|
|
|
|
`RSVP.map` is similar to JavaScript's native `map` method, except that it
|
|
waits for all promises to become fulfilled before running the `mapFn` on
|
|
each item in given to `promises`. `RSVP.map` returns a promise that will
|
|
become fulfilled with the result of running `mapFn` on the values the promises
|
|
become fulfilled with.
|
|
|
|
For example:
|
|
|
|
```javascript
|
|
|
|
var promise1 = RSVP.resolve(1);
|
|
var promise2 = RSVP.resolve(2);
|
|
var promise3 = RSVP.resolve(3);
|
|
var promises = [ promise1, promise2, promise3 ];
|
|
|
|
var mapFn = function(item){
|
|
return item + 1;
|
|
};
|
|
|
|
RSVP.map(promises, mapFn).then(function(result){
|
|
// result is [ 2, 3, 4 ]
|
|
});
|
|
```
|
|
|
|
If any of the `promises` given to `RSVP.map` are rejected, the first promise
|
|
that is rejected will be given as an argument to the returned promises's
|
|
rejection handler. For example:
|
|
|
|
```javascript
|
|
var promise1 = RSVP.resolve(1);
|
|
var promise2 = RSVP.reject(new Error("2"));
|
|
var promise3 = RSVP.reject(new Error("3"));
|
|
var promises = [ promise1, promise2, promise3 ];
|
|
|
|
var mapFn = function(item){
|
|
return item + 1;
|
|
};
|
|
|
|
RSVP.map(promises, mapFn).then(function(array){
|
|
// Code here never runs because there are rejected promises!
|
|
}, function(reason) {
|
|
// reason.message === "2"
|
|
});
|
|
```
|
|
|
|
`RSVP.map` will also wait if a promise is returned from `mapFn`. For example,
|
|
say you want to get all comments from a set of blog posts, but you need
|
|
the blog posts first becuase they contain a url to those comments.
|
|
|
|
```javscript
|
|
|
|
var mapFn = function(blogPost){
|
|
// getComments does some ajax and returns an RSVP.Promise that is fulfilled
|
|
// with some comments data
|
|
return getComments(blogPost.comments_url);
|
|
};
|
|
|
|
// getBlogPosts does some ajax and returns an RSVP.Promise that is fulfilled
|
|
// with some blog post data
|
|
RSVP.map(getBlogPosts(), mapFn).then(function(comments){
|
|
// comments is the result of asking the server for the comments
|
|
// of all blog posts returned from getBlogPosts()
|
|
});
|
|
```
|
|
|
|
@method map
|
|
@for RSVP
|
|
@param {Array} promises
|
|
@param {Function} mapFn function to be called on each fulfilled promise.
|
|
@param {String} label optional string for labelling the promise.
|
|
Useful for tooling.
|
|
@return {Promise} promise that is fulfilled with the result of calling
|
|
`mapFn` on each fulfilled promise or value when they become fulfilled.
|
|
The promise will be rejected if any of the given `promises` become rejected.
|
|
*/
|
|
__exports__["default"] = function map(promises, mapFn, label) {
|
|
|
|
if (!isArray(promises)) {
|
|
throw new TypeError('You must pass an array to map.');
|
|
}
|
|
|
|
if (!isFunction(mapFn)){
|
|
throw new TypeError("You must pass a function to map's second argument.");
|
|
}
|
|
|
|
return all(promises, label).then(function(results){
|
|
var resultLen = results.length,
|
|
mappedResults = [],
|
|
i;
|
|
|
|
for (i = 0; i < resultLen; i++){
|
|
mappedResults.push(mapFn(results[i]));
|
|
}
|
|
|
|
return all(mappedResults, label);
|
|
});
|
|
};
|
|
});
|
|
define("rsvp/node",
|
|
["./promise","exports"],
|
|
function(__dependency1__, __exports__) {
|
|
"use strict";
|
|
var Promise = __dependency1__["default"];
|
|
|
|
var slice = Array.prototype.slice;
|
|
|
|
function makeNodeCallbackFor(resolve, reject) {
|
|
return function (error, value) {
|
|
if (error) {
|
|
reject(error);
|
|
} else if (arguments.length > 2) {
|
|
resolve(slice.call(arguments, 1));
|
|
} else {
|
|
resolve(value);
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
`RSVP.denodeify` takes a "node-style" function and returns a function that
|
|
will return an `RSVP.Promise`. You can use `denodeify` in Node.js or the
|
|
browser when you'd prefer to use promises over using callbacks. For example,
|
|
`denodeify` transforms the following:
|
|
|
|
```javascript
|
|
var fs = require('fs');
|
|
|
|
fs.readFile('myfile.txt', function(err, data){
|
|
if (err) return handleError(err);
|
|
handleData(data);
|
|
});
|
|
```
|
|
|
|
into:
|
|
|
|
```javascript
|
|
var fs = require('fs');
|
|
|
|
var readFile = RSVP.denodeify(fs.readFile);
|
|
|
|
readFile('myfile.txt').then(handleData, handleError);
|
|
```
|
|
|
|
Using `denodeify` makes it easier to compose asynchronous operations instead
|
|
of using callbacks. For example, instead of:
|
|
|
|
```javascript
|
|
var fs = require('fs');
|
|
var log = require('some-async-logger');
|
|
|
|
fs.readFile('myfile.txt', function(err, data){
|
|
if (err) return handleError(err);
|
|
fs.writeFile('myfile2.txt', data, function(err){
|
|
if (err) throw err;
|
|
log('success', function(err) {
|
|
if (err) throw err;
|
|
});
|
|
});
|
|
});
|
|
```
|
|
|
|
You can chain the operations together using `then` from the returned promise:
|
|
|
|
```javascript
|
|
var fs = require('fs');
|
|
var denodeify = RSVP.denodeify;
|
|
var readFile = denodeify(fs.readFile);
|
|
var writeFile = denodeify(fs.writeFile);
|
|
var log = denodeify(require('some-async-logger'));
|
|
|
|
readFile('myfile.txt').then(function(data){
|
|
return writeFile('myfile2.txt', data);
|
|
}).then(function(){
|
|
return log('SUCCESS');
|
|
}).then(function(){
|
|
// success handler
|
|
}, function(reason){
|
|
// rejection handler
|
|
});
|
|
```
|
|
|
|
@method denodeify
|
|
@for RSVP
|
|
@param {Function} nodeFunc a "node-style" function that takes a callback as
|
|
its last argument. The callback expects an error to be passed as its first
|
|
argument (if an error occurred, otherwise null), and the value from the
|
|
operation as its second argument ("function(err, value){ }").
|
|
@param {Any} binding optional argument for binding the "this" value when
|
|
calling the `nodeFunc` function.
|
|
@return {Function} a function that wraps `nodeFunc` to return an
|
|
`RSVP.Promise`
|
|
*/
|
|
__exports__["default"] = function denodeify(nodeFunc, binding) {
|
|
return function() {
|
|
var nodeArgs = slice.call(arguments), resolve, reject;
|
|
var thisArg = this || binding;
|
|
|
|
return new Promise(function(resolve, reject) {
|
|
Promise.all(nodeArgs).then(function(nodeArgs) {
|
|
try {
|
|
nodeArgs.push(makeNodeCallbackFor(resolve, reject));
|
|
nodeFunc.apply(thisArg, nodeArgs);
|
|
} catch(e) {
|
|
reject(e);
|
|
}
|
|
});
|
|
});
|
|
};
|
|
};
|
|
});
|
|
define("rsvp/promise",
|
|
["./config","./events","./instrument","./utils","./promise/cast","./promise/all","./promise/race","./promise/resolve","./promise/reject","exports"],
|
|
function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __exports__) {
|
|
"use strict";
|
|
var config = __dependency1__.config;
|
|
var EventTarget = __dependency2__["default"];
|
|
var instrument = __dependency3__["default"];
|
|
var objectOrFunction = __dependency4__.objectOrFunction;
|
|
var isFunction = __dependency4__.isFunction;
|
|
var now = __dependency4__.now;
|
|
var cast = __dependency5__["default"];
|
|
var all = __dependency6__["default"];
|
|
var race = __dependency7__["default"];
|
|
var Resolve = __dependency8__["default"];
|
|
var Reject = __dependency9__["default"];
|
|
|
|
var guidKey = 'rsvp_' + now() + '-';
|
|
var counter = 0;
|
|
|
|
function noop() {}
|
|
|
|
__exports__["default"] = Promise;
|
|
function Promise(resolver, label) {
|
|
if (!isFunction(resolver)) {
|
|
throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
|
|
}
|
|
|
|
if (!(this instanceof Promise)) {
|
|
throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
|
|
}
|
|
|
|
this._id = counter++;
|
|
this._label = label;
|
|
this._subscribers = [];
|
|
|
|
if (config.instrument) {
|
|
instrument('created', this);
|
|
}
|
|
|
|
if (noop !== resolver) {
|
|
invokeResolver(resolver, this);
|
|
}
|
|
}
|
|
|
|
function invokeResolver(resolver, promise) {
|
|
function resolvePromise(value) {
|
|
resolve(promise, value);
|
|
}
|
|
|
|
function rejectPromise(reason) {
|
|
reject(promise, reason);
|
|
}
|
|
|
|
try {
|
|
resolver(resolvePromise, rejectPromise);
|
|
} catch(e) {
|
|
rejectPromise(e);
|
|
}
|
|
}
|
|
|
|
Promise.cast = cast;
|
|
Promise.all = all;
|
|
Promise.race = race;
|
|
Promise.resolve = Resolve;
|
|
Promise.reject = Reject;
|
|
|
|
var PENDING = void 0;
|
|
var SEALED = 0;
|
|
var FULFILLED = 1;
|
|
var REJECTED = 2;
|
|
|
|
function subscribe(parent, child, onFulfillment, onRejection) {
|
|
var subscribers = parent._subscribers;
|
|
var length = subscribers.length;
|
|
|
|
subscribers[length] = child;
|
|
subscribers[length + FULFILLED] = onFulfillment;
|
|
subscribers[length + REJECTED] = onRejection;
|
|
}
|
|
|
|
function publish(promise, settled) {
|
|
var child, callback, subscribers = promise._subscribers, detail = promise._detail;
|
|
|
|
if (config.instrument) {
|
|
instrument(settled === FULFILLED ? 'fulfilled' : 'rejected', promise);
|
|
}
|
|
|
|
for (var i = 0; i < subscribers.length; i += 3) {
|
|
child = subscribers[i];
|
|
callback = subscribers[i + settled];
|
|
|
|
invokeCallback(settled, child, callback, detail);
|
|
}
|
|
|
|
promise._subscribers = null;
|
|
}
|
|
|
|
Promise.prototype = {
|
|
constructor: Promise,
|
|
|
|
_id: undefined,
|
|
_guidKey: guidKey,
|
|
_label: undefined,
|
|
|
|
_state: undefined,
|
|
_detail: undefined,
|
|
_subscribers: undefined,
|
|
|
|
_onerror: function (reason) {
|
|
config.trigger('error', reason);
|
|
},
|
|
|
|
then: function(onFulfillment, onRejection, label) {
|
|
var promise = this;
|
|
this._onerror = null;
|
|
|
|
var thenPromise = new this.constructor(noop, label);
|
|
|
|
if (this._state) {
|
|
var callbacks = arguments;
|
|
config.async(function invokePromiseCallback() {
|
|
invokeCallback(promise._state, thenPromise, callbacks[promise._state - 1], promise._detail);
|
|
});
|
|
} else {
|
|
subscribe(this, thenPromise, onFulfillment, onRejection);
|
|
}
|
|
|
|
if (config.instrument) {
|
|
instrument('chained', promise, thenPromise);
|
|
}
|
|
|
|
return thenPromise;
|
|
},
|
|
|
|
'catch': function(onRejection, label) {
|
|
return this.then(null, onRejection, label);
|
|
},
|
|
|
|
'finally': function(callback, label) {
|
|
var constructor = this.constructor;
|
|
|
|
return this.then(function(value) {
|
|
return constructor.cast(callback()).then(function(){
|
|
return value;
|
|
});
|
|
}, function(reason) {
|
|
return constructor.cast(callback()).then(function(){
|
|
throw reason;
|
|
});
|
|
}, label);
|
|
}
|
|
};
|
|
|
|
function invokeCallback(settled, promise, callback, detail) {
|
|
var hasCallback = isFunction(callback),
|
|
value, error, succeeded, failed;
|
|
|
|
if (hasCallback) {
|
|
try {
|
|
value = callback(detail);
|
|
succeeded = true;
|
|
} catch(e) {
|
|
failed = true;
|
|
error = e;
|
|
}
|
|
} else {
|
|
value = detail;
|
|
succeeded = true;
|
|
}
|
|
|
|
if (handleThenable(promise, value)) {
|
|
return;
|
|
} else if (hasCallback && succeeded) {
|
|
resolve(promise, value);
|
|
} else if (failed) {
|
|
reject(promise, error);
|
|
} else if (settled === FULFILLED) {
|
|
resolve(promise, value);
|
|
} else if (settled === REJECTED) {
|
|
reject(promise, value);
|
|
}
|
|
}
|
|
|
|
function handleThenable(promise, value) {
|
|
var then = null,
|
|
resolved;
|
|
|
|
try {
|
|
if (promise === value) {
|
|
throw new TypeError("A promises callback cannot return that same promise.");
|
|
}
|
|
|
|
if (objectOrFunction(value)) {
|
|
then = value.then;
|
|
|
|
if (isFunction(then)) {
|
|
then.call(value, function(val) {
|
|
if (resolved) { return true; }
|
|
resolved = true;
|
|
|
|
if (value !== val) {
|
|
resolve(promise, val);
|
|
} else {
|
|
fulfill(promise, val);
|
|
}
|
|
}, function(val) {
|
|
if (resolved) { return true; }
|
|
resolved = true;
|
|
|
|
reject(promise, val);
|
|
}, 'derived from: ' + (promise._label || ' unknown promise'));
|
|
|
|
return true;
|
|
}
|
|
}
|
|
} catch (error) {
|
|
if (resolved) { return true; }
|
|
reject(promise, error);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function resolve(promise, value) {
|
|
if (promise === value) {
|
|
fulfill(promise, value);
|
|
} else if (!handleThenable(promise, value)) {
|
|
fulfill(promise, value);
|
|
}
|
|
}
|
|
|
|
function fulfill(promise, value) {
|
|
if (promise._state !== PENDING) { return; }
|
|
promise._state = SEALED;
|
|
promise._detail = value;
|
|
|
|
config.async(publishFulfillment, promise);
|
|
}
|
|
|
|
function reject(promise, reason) {
|
|
if (promise._state !== PENDING) { return; }
|
|
promise._state = SEALED;
|
|
promise._detail = reason;
|
|
|
|
config.async(publishRejection, promise);
|
|
}
|
|
|
|
function publishFulfillment(promise) {
|
|
publish(promise, promise._state = FULFILLED);
|
|
}
|
|
|
|
function publishRejection(promise) {
|
|
if (promise._onerror) {
|
|
promise._onerror(promise._detail);
|
|
}
|
|
|
|
publish(promise, promise._state = REJECTED);
|
|
}
|
|
});
|
|
define("rsvp/promise/all",
|
|
["../utils","exports"],
|
|
function(__dependency1__, __exports__) {
|
|
"use strict";
|
|
var isArray = __dependency1__.isArray;
|
|
var isNonThenable = __dependency1__.isNonThenable;
|
|
|
|
/**
|
|
Returns a promise that is fulfilled when all the given promises have been
|
|
fulfilled, or rejected if any of them become rejected. The return promise
|
|
is fulfilled with an array that gives all the values in the order they were
|
|
passed in the `promises` array argument.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
var promise1 = RSVP.resolve(1);
|
|
var promise2 = RSVP.resolve(2);
|
|
var promise3 = RSVP.resolve(3);
|
|
var promises = [ promise1, promise2, promise3 ];
|
|
|
|
RSVP.Promise.all(promises).then(function(array){
|
|
// The array here would be [ 1, 2, 3 ];
|
|
});
|
|
```
|
|
|
|
If any of the `promises` given to `RSVP.all` are rejected, the first promise
|
|
that is rejected will be given as an argument to the returned promises's
|
|
rejection handler. For example:
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
var promise1 = RSVP.resolve(1);
|
|
var promise2 = RSVP.reject(new Error("2"));
|
|
var promise3 = RSVP.reject(new Error("3"));
|
|
var promises = [ promise1, promise2, promise3 ];
|
|
|
|
RSVP.Promise.all(promises).then(function(array){
|
|
// Code here never runs because there are rejected promises!
|
|
}, function(error) {
|
|
// error.message === "2"
|
|
});
|
|
```
|
|
|
|
@method all
|
|
@for RSVP.Promise
|
|
@param {Array} promises
|
|
@param {String} label
|
|
@return {Promise} promise that is fulfilled when all `promises` have been
|
|
fulfilled, or rejected if any of them become rejected.
|
|
*/
|
|
__exports__["default"] = function all(entries, label) {
|
|
if (!isArray(entries)) {
|
|
throw new TypeError('You must pass an array to all.');
|
|
}
|
|
|
|
/*jshint validthis:true */
|
|
var Constructor = this;
|
|
|
|
return new Constructor(function(resolve, reject) {
|
|
var remaining = entries.length;
|
|
var results = new Array(remaining);
|
|
var entry, pending = true;
|
|
|
|
if (remaining === 0) {
|
|
resolve(results);
|
|
return;
|
|
}
|
|
|
|
function fulfillmentAt(index) {
|
|
return function(value) {
|
|
results[index] = value;
|
|
if (--remaining === 0) {
|
|
resolve(results);
|
|
}
|
|
};
|
|
}
|
|
|
|
function onRejection(reason) {
|
|
remaining = 0;
|
|
reject(reason);
|
|
}
|
|
|
|
for (var index = 0; index < entries.length; index++) {
|
|
entry = entries[index];
|
|
if (isNonThenable(entry)) {
|
|
results[index] = entry;
|
|
if (--remaining === 0) {
|
|
resolve(results);
|
|
}
|
|
} else {
|
|
Constructor.cast(entry).then(fulfillmentAt(index), onRejection);
|
|
}
|
|
}
|
|
}, label);
|
|
};
|
|
});
|
|
define("rsvp/promise/cast",
|
|
["exports"],
|
|
function(__exports__) {
|
|
"use strict";
|
|
/**
|
|
`RSVP.Promise.cast` returns the same promise if that promise shares a constructor
|
|
with the promise being casted.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
var promise = RSVP.resolve(1);
|
|
var casted = RSVP.Promise.cast(promise);
|
|
|
|
console.log(promise === casted); // true
|
|
```
|
|
|
|
In the case of a promise whose constructor does not match, it is assimilated.
|
|
The resulting promise will fulfill or reject based on the outcome of the
|
|
promise being casted.
|
|
|
|
In the case of a non-promise, a promise which will fulfill with that value is
|
|
returned.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
var value = 1; // could be a number, boolean, string, undefined...
|
|
var casted = RSVP.Promise.cast(value);
|
|
|
|
console.log(value === casted); // false
|
|
console.log(casted instanceof RSVP.Promise) // true
|
|
|
|
casted.then(function(val) {
|
|
val === value // => true
|
|
});
|
|
```
|
|
|
|
`RSVP.Promise.cast` is similar to `RSVP.resolve`, but `RSVP.Promise.cast` differs in the
|
|
following ways:
|
|
* `RSVP.Promise.cast` serves as a memory-efficient way of getting a promise, when you
|
|
have something that could either be a promise or a value. RSVP.resolve
|
|
will have the same effect but will create a new promise wrapper if the
|
|
argument is a promise.
|
|
* `RSVP.Promise.cast` is a way of casting incoming thenables or promise subclasses to
|
|
promises of the exact class specified, so that the resulting object's `then` is
|
|
ensured to have the behavior of the constructor you are calling cast on (i.e., RSVP.Promise).
|
|
|
|
@method cast
|
|
@for RSVP.Promise
|
|
@param {Object} object to be casted
|
|
@return {Promise} promise that is fulfilled when all properties of `promises`
|
|
have been fulfilled, or rejected if any of them become rejected.
|
|
*/
|
|
|
|
__exports__["default"] = function cast(object) {
|
|
/*jshint validthis:true */
|
|
var Constructor = this;
|
|
|
|
if (object && typeof object === 'object' && object.constructor === Constructor) {
|
|
return object;
|
|
}
|
|
|
|
return new Constructor(function(resolve) {
|
|
resolve(object);
|
|
});
|
|
};
|
|
});
|
|
define("rsvp/promise/race",
|
|
["../utils","exports"],
|
|
function(__dependency1__, __exports__) {
|
|
"use strict";
|
|
/* global toString */
|
|
|
|
var isArray = __dependency1__.isArray;
|
|
var isFunction = __dependency1__.isFunction;
|
|
var isNonThenable = __dependency1__.isNonThenable;
|
|
|
|
/**
|
|
`RSVP.Promise.race` allows you to watch a series of promises and act as soon as the
|
|
first promise given to the `promises` argument fulfills or rejects.
|
|
|
|
Example:
|
|
|
|
```javascript
|
|
var promise1 = new RSVP.Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve("promise 1");
|
|
}, 200);
|
|
});
|
|
|
|
var promise2 = new RSVP.Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve("promise 2");
|
|
}, 100);
|
|
});
|
|
|
|
RSVP.Promise.race([promise1, promise2]).then(function(result){
|
|
// result === "promise 2" because it was resolved before promise1
|
|
// was resolved.
|
|
});
|
|
```
|
|
|
|
`RSVP.race` is deterministic in that only the state of the first completed
|
|
promise matters. For example, even if other promises given to the `promises`
|
|
array argument are resolved, but the first completed promise has become
|
|
rejected before the other promises became fulfilled, the returned promise
|
|
will become rejected:
|
|
|
|
```javascript
|
|
var promise1 = new RSVP.Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
resolve("promise 1");
|
|
}, 200);
|
|
});
|
|
|
|
var promise2 = new RSVP.Promise(function(resolve, reject){
|
|
setTimeout(function(){
|
|
reject(new Error("promise 2"));
|
|
}, 100);
|
|
});
|
|
|
|
RSVP.Promise.race([promise1, promise2]).then(function(result){
|
|
// Code here never runs because there are rejected promises!
|
|
}, function(reason){
|
|
// reason.message === "promise2" because promise 2 became rejected before
|
|
// promise 1 became fulfilled
|
|
});
|
|
```
|
|
|
|
@method race
|
|
@for RSVP.Promise
|
|
@param {Array} promises array of promises to observe
|
|
@param {String} label optional string for describing the promise returned.
|
|
Useful for tooling.
|
|
@return {Promise} a promise that becomes fulfilled with the value the first
|
|
completed promises is resolved with if the first completed promise was
|
|
fulfilled, or rejected with the reason that the first completed promise
|
|
was rejected with.
|
|
*/
|
|
__exports__["default"] = function race(entries, label) {
|
|
if (!isArray(entries)) {
|
|
throw new TypeError('You must pass an array to race.');
|
|
}
|
|
|
|
/*jshint validthis:true */
|
|
var Constructor = this, entry;
|
|
|
|
return new Constructor(function(resolve, reject) {
|
|
var pending = true;
|
|
|
|
function onFulfillment(value) { if (pending) { pending = false; resolve(value); } }
|
|
function onRejection(reason) { if (pending) { pending = false; reject(reason); } }
|
|
|
|
for (var i = 0; i < entries.length; i++) {
|
|
entry = entries[i];
|
|
if (isNonThenable(entry)) {
|
|
pending = false;
|
|
resolve(entry);
|
|
return;
|
|
} else {
|
|
Constructor.cast(entry).then(onFulfillment, onRejection);
|
|
}
|
|
}
|
|
}, label);
|
|
};
|
|
});
|
|
define("rsvp/promise/reject",
|
|
["exports"],
|
|
function(__exports__) {
|
|
"use strict";
|
|
/**
|
|
`RSVP.reject` returns a promise that will become rejected with the passed
|
|
`reason`. `RSVP.reject` is essentially shorthand for the following:
|
|
|
|
```javascript
|
|
var promise = new RSVP.Promise(function(resolve, reject){
|
|
reject(new Error('WHOOPS'));
|
|
});
|
|
|
|
promise.then(function(value){
|
|
// Code here doesn't run because the promise is rejected!
|
|
}, function(reason){
|
|
// reason.message === 'WHOOPS'
|
|
});
|
|
```
|
|
|
|
Instead of writing the above, your code now simply becomes the following:
|
|
|
|
```javascript
|
|
var promise = RSVP.reject(new Error('WHOOPS'));
|
|
|
|
promise.then(function(value){
|
|
// Code here doesn't run because the promise is rejected!
|
|
}, function(reason){
|
|
// reason.message === 'WHOOPS'
|
|
});
|
|
```
|
|
|
|
@method reject
|
|
@for RSVP.Promise
|
|
@param {Any} reason value that the returned promise will be rejected with.
|
|
@param {String} label optional string for identifying the returned promise.
|
|
Useful for tooling.
|
|
@return {Promise} a promise that will become rejected with the given
|
|
`reason`.
|
|
*/
|
|
__exports__["default"] = function reject(reason, label) {
|
|
/*jshint validthis:true */
|
|
var Constructor = this;
|
|
|
|
return new Constructor(function (resolve, reject) {
|
|
reject(reason);
|
|
}, label);
|
|
};
|
|
});
|
|
define("rsvp/promise/resolve",
|
|
["exports"],
|
|
function(__exports__) {
|
|
"use strict";
|
|
/**
|
|
`RSVP.resolve` returns a promise that will become fulfilled with the passed
|
|
`value`. `RSVP.resolve` is essentially shorthand for the following:
|
|
|
|
```javascript
|
|
var promise = new RSVP.Promise(function(resolve, reject){
|
|
resolve(1);
|
|
});
|
|
|
|
promise.then(function(value){
|
|
// value === 1
|
|
});
|
|
```
|
|
|
|
Instead of writing the above, your code now simply becomes the following:
|
|
|
|
```javascript
|
|
var promise = RSVP.resolve(1);
|
|
|
|
promise.then(function(value){
|
|
// value === 1
|
|
});
|
|
```
|
|
|
|
@method resolve
|
|
@for RSVP.Promise
|
|
@param {Any} value value that the returned promise will be resolved with
|
|
@param {String} label optional string for identifying the returned promise.
|
|
Useful for tooling.
|
|
@return {Promise} a promise that will become fulfilled with the given
|
|
`value`
|
|
*/
|
|
__exports__["default"] = function resolve(value, label) {
|
|
/*jshint validthis:true */
|
|
var Constructor = this;
|
|
|
|
return new Constructor(function(resolve, reject) {
|
|
resolve(value);
|
|
}, label);
|
|
};
|
|
});
|
|
define("rsvp/race",
|
|
["./promise","exports"],
|
|
function(__dependency1__, __exports__) {
|
|
"use strict";
|
|
var Promise = __dependency1__["default"];
|
|
|
|
__exports__["default"] = function race(array, label) {
|
|
return Promise.race(array, label);
|
|
};
|
|
});
|
|
define("rsvp/reject",
|
|
["./promise","exports"],
|
|
function(__dependency1__, __exports__) {
|
|
"use strict";
|
|
var Promise = __dependency1__["default"];
|
|
|
|
__exports__["default"] = function reject(reason, label) {
|
|
return Promise.reject(reason, label);
|
|
};
|
|
});
|
|
define("rsvp/resolve",
|
|
["./promise","exports"],
|
|
function(__dependency1__, __exports__) {
|
|
"use strict";
|
|
var Promise = __dependency1__["default"];
|
|
|
|
__exports__["default"] = function resolve(value, label) {
|
|
return Promise.resolve(value, label);
|
|
};
|
|
});
|
|
define("rsvp/rethrow",
|
|
["exports"],
|
|
function(__exports__) {
|
|
"use strict";
|
|
/**
|
|
`RSVP.rethrow` will rethrow an error on the next turn of the JavaScript event
|
|
loop in order to aid debugging.
|
|
|
|
Promises A+ specifies that any exceptions that occur with a promise must be
|
|
caught by the promises implementation and bubbled to the last handler. For
|
|
this reason, it is recommended that you always specify a second rejection
|
|
handler function to `then`. However, `RSVP.rethrow` will throw the exception
|
|
outside of the promise, so it bubbles up to your console if in the browser,
|
|
or domain/cause uncaught exception in Node. `rethrow` will throw the error
|
|
again so the error can be handled by the promise.
|
|
|
|
```javascript
|
|
function throws(){
|
|
throw new Error('Whoops!');
|
|
}
|
|
|
|
var promise = new RSVP.Promise(function(resolve, reject){
|
|
throws();
|
|
});
|
|
|
|
promise.fail(RSVP.rethrow).then(function(){
|
|
// Code here doesn't run because the promise became rejected due to an
|
|
// error!
|
|
}, function (err){
|
|
// handle the error here
|
|
});
|
|
```
|
|
|
|
The 'Whoops' error will be thrown on the next turn of the event loop
|
|
and you can watch for it in your console. You can also handle it using a
|
|
rejection handler given to `.then` or `.fail` on the returned promise.
|
|
|
|
@method rethrow
|
|
@for RSVP
|
|
@param {Error} reason reason the promise became rejected.
|
|
@throws Error
|
|
*/
|
|
__exports__["default"] = function rethrow(reason) {
|
|
setTimeout(function() {
|
|
throw reason;
|
|
});
|
|
throw reason;
|
|
};
|
|
});
|
|
define("rsvp/utils",
|
|
["exports"],
|
|
function(__exports__) {
|
|
"use strict";
|
|
function objectOrFunction(x) {
|
|
return typeof x === "function" || (typeof x === "object" && x !== null);
|
|
}
|
|
|
|
__exports__.objectOrFunction = objectOrFunction;function isFunction(x) {
|
|
return typeof x === "function";
|
|
}
|
|
|
|
__exports__.isFunction = isFunction;function isNonThenable(x) {
|
|
return !objectOrFunction(x);
|
|
}
|
|
|
|
__exports__.isNonThenable = isNonThenable;function isArray(x) {
|
|
return Object.prototype.toString.call(x) === "[object Array]";
|
|
}
|
|
|
|
__exports__.isArray = isArray;// Date.now is not available in browsers < IE9
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now#Compatibility
|
|
var now = Date.now || function() { return new Date().getTime(); };
|
|
__exports__.now = now;
|
|
var keysOf = Object.keys || function(object) {
|
|
var result = [];
|
|
|
|
for (var prop in object) {
|
|
result.push(prop);
|
|
}
|
|
|
|
return result;
|
|
};
|
|
__exports__.keysOf = keysOf;
|
|
});
|
|
define("rsvp",
|
|
["./rsvp/promise","./rsvp/events","./rsvp/node","./rsvp/all","./rsvp/race","./rsvp/hash","./rsvp/rethrow","./rsvp/defer","./rsvp/config","./rsvp/map","./rsvp/resolve","./rsvp/reject","./rsvp/asap","./rsvp/filter","exports"],
|
|
function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __exports__) {
|
|
"use strict";
|
|
var Promise = __dependency1__["default"];
|
|
var EventTarget = __dependency2__["default"];
|
|
var denodeify = __dependency3__["default"];
|
|
var all = __dependency4__["default"];
|
|
var race = __dependency5__["default"];
|
|
var hash = __dependency6__["default"];
|
|
var rethrow = __dependency7__["default"];
|
|
var defer = __dependency8__["default"];
|
|
var config = __dependency9__.config;
|
|
var configure = __dependency9__.configure;
|
|
var map = __dependency10__["default"];
|
|
var resolve = __dependency11__["default"];
|
|
var reject = __dependency12__["default"];
|
|
var asap = __dependency13__["default"];
|
|
var filter = __dependency14__["default"];
|
|
|
|
config.async = asap; // default async is asap;
|
|
|
|
function async(callback, arg) {
|
|
config.async(callback, arg);
|
|
}
|
|
|
|
function on() {
|
|
config.on.apply(config, arguments);
|
|
}
|
|
|
|
function off() {
|
|
config.off.apply(config, arguments);
|
|
}
|
|
|
|
// Set up instrumentation through `window.__PROMISE_INTRUMENTATION__`
|
|
if (typeof window !== 'undefined' && typeof window.__PROMISE_INSTRUMENTATION__ === 'object') {
|
|
var callbacks = window.__PROMISE_INSTRUMENTATION__;
|
|
configure('instrument', true);
|
|
for (var eventName in callbacks) {
|
|
if (callbacks.hasOwnProperty(eventName)) {
|
|
on(eventName, callbacks[eventName]);
|
|
}
|
|
}
|
|
}
|
|
|
|
__exports__.Promise = Promise;
|
|
__exports__.EventTarget = EventTarget;
|
|
__exports__.all = all;
|
|
__exports__.race = race;
|
|
__exports__.hash = hash;
|
|
__exports__.rethrow = rethrow;
|
|
__exports__.defer = defer;
|
|
__exports__.denodeify = denodeify;
|
|
__exports__.configure = configure;
|
|
__exports__.on = on;
|
|
__exports__.off = off;
|
|
__exports__.resolve = resolve;
|
|
__exports__.reject = reject;
|
|
__exports__.async = async;
|
|
__exports__.map = map;
|
|
__exports__.filter = filter;
|
|
});
|
|
global.RSVP = requireModule('rsvp');
|
|
}(window));
|
|
'use strict';
|
|
|
|
var EPUBJS = EPUBJS || {};
|
|
EPUBJS.VERSION = "0.2.0";
|
|
|
|
EPUBJS.plugins = EPUBJS.plugins || {};
|
|
|
|
EPUBJS.filePath = EPUBJS.filePath || "/epubjs/";
|
|
|
|
EPUBJS.Render = {};
|
|
|
|
(function(root) {
|
|
|
|
var previousEpub = root.ePub || {};
|
|
|
|
var ePub = root.ePub = function() {
|
|
var bookPath, options;
|
|
|
|
//-- var book = ePub("path/to/book.epub", { restore: true })
|
|
if(typeof(arguments[0]) != 'undefined' &&
|
|
typeof arguments[0] === 'string') {
|
|
|
|
bookPath = arguments[0];
|
|
|
|
if( arguments[1] && typeof arguments[1] === 'object' ) {
|
|
options = arguments[1];
|
|
options.bookPath = bookPath;
|
|
} else {
|
|
options = { 'bookPath' : bookPath };
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* var book = ePub({ bookPath: "path/to/book.epub", restore: true });
|
|
*
|
|
* - OR -
|
|
*
|
|
* var book = ePub({ restore: true });
|
|
* book.open("path/to/book.epub");
|
|
*/
|
|
|
|
if( arguments[0] && typeof arguments[0] === 'object' ) {
|
|
options = arguments[0];
|
|
}
|
|
|
|
|
|
return new EPUBJS.Book(options);
|
|
};
|
|
|
|
_.extend(ePub, {
|
|
noConflict : function() {
|
|
root.ePub = previousEpub;
|
|
return this;
|
|
}
|
|
});
|
|
|
|
//exports to multiple environments
|
|
if (typeof define === 'function' && define.amd)
|
|
//AMD
|
|
define(function(){ return ePub; });
|
|
else if (typeof module != "undefined" && module.exports)
|
|
//Node
|
|
module.exports = ePub;
|
|
|
|
})(window);
|
|
EPUBJS.Book = function(options){
|
|
|
|
var book = this;
|
|
|
|
this.settings = _.defaults(options || {}, {
|
|
bookPath : null,
|
|
bookKey : null,
|
|
packageUrl : null,
|
|
storage: false, //-- true (auto) or false (none) | override: 'ram', 'websqldatabase', 'indexeddb', 'filesystem'
|
|
fromStorage : false,
|
|
saved : false,
|
|
online : true,
|
|
contained : false,
|
|
width : null,
|
|
height: null,
|
|
layoutOveride : null, // Default: { spread: 'reflowable', layout: 'auto', orientation: 'auto'}
|
|
orientation : null,
|
|
minSpreadWidth: 800, //-- overridden by spread: none (never) / both (always)
|
|
version: 1,
|
|
restore: false,
|
|
reload : false,
|
|
goto : false,
|
|
styles : {},
|
|
headTags : {},
|
|
withCredentials: false,
|
|
render_method: "Iframe"
|
|
});
|
|
|
|
this.settings.EPUBJSVERSION = EPUBJS.VERSION;
|
|
|
|
this.spinePos = 0;
|
|
this.stored = false;
|
|
|
|
//-- All Book events for listening
|
|
/*
|
|
book:ready
|
|
book:stored
|
|
book:online
|
|
book:offline
|
|
book:pageChanged
|
|
*/
|
|
|
|
//-- Adds Hook methods to the Book prototype
|
|
// Hooks will all return before triggering the callback.
|
|
// EPUBJS.Hooks.mixin(this);
|
|
//-- Get pre-registered hooks for events
|
|
// this.getHooks("beforeChapterDisplay");
|
|
|
|
this.online = this.settings.online || navigator.onLine;
|
|
this.networkListeners();
|
|
|
|
this.store = false; //-- False if not using storage;
|
|
|
|
//-- Determine storage method
|
|
//-- Override options: none | ram | websqldatabase | indexeddb | filesystem
|
|
|
|
if(this.settings.storage !== false){
|
|
this.storage = new fileStorage.storage(this.settings.storage);
|
|
}
|
|
|
|
this.ready = {
|
|
manifest: new RSVP.defer(),
|
|
spine: new RSVP.defer(),
|
|
metadata: new RSVP.defer(),
|
|
cover: new RSVP.defer(),
|
|
toc: new RSVP.defer(),
|
|
pageList: new RSVP.defer()
|
|
};
|
|
|
|
this.readyPromises = [
|
|
this.ready.manifest.promise,
|
|
this.ready.spine.promise,
|
|
this.ready.metadata.promise,
|
|
this.ready.cover.promise,
|
|
this.ready.toc.promise
|
|
];
|
|
|
|
this.pageList = [];
|
|
this.pagination = new EPUBJS.Pagination();
|
|
this.pageListReady = this.ready.pageList.promise;
|
|
|
|
this.ready.all = RSVP.all(this.readyPromises);
|
|
|
|
this.ready.all.then(this._ready.bind(this));
|
|
|
|
// Queue for methods used before rendering
|
|
this.isRendered = false;
|
|
this._q = EPUBJS.core.queue(this);
|
|
// Queue for rendering
|
|
this._rendering = false;
|
|
this._displayQ = EPUBJS.core.queue(this);
|
|
// Queue for going to another location
|
|
this._moving = false;
|
|
this._gotoQ = EPUBJS.core.queue(this);
|
|
|
|
/**
|
|
* Creates a new renderer.
|
|
* The renderer will handle displaying the content using the method provided in the settings
|
|
*/
|
|
this.renderer = new EPUBJS.Renderer(this.settings.render_method);
|
|
//-- Set the width at which to switch from spreads to single pages
|
|
this.renderer.setMinSpreadWidth(this.settings.minSpreadWidth);
|
|
//-- Pass through the renderer events
|
|
this.listenToRenderer(this.renderer);
|
|
|
|
this.defer_opened = new RSVP.defer();
|
|
this.opened = this.defer_opened.promise;
|
|
// BookUrl is optional, but if present start loading process
|
|
if(typeof this.settings.bookPath === 'string') {
|
|
this.open(this.settings.bookPath, this.settings.reload);
|
|
}
|
|
|
|
window.addEventListener("beforeunload", this.unload.bind(this), false);
|
|
|
|
//-- Listen for these promises:
|
|
//-- book.opened.then()
|
|
//-- book.rendered.then()
|
|
};
|
|
|
|
//-- Check bookUrl and start parsing book Assets or load them from storage
|
|
EPUBJS.Book.prototype.open = function(bookPath, forceReload){
|
|
var book = this,
|
|
epubpackage,
|
|
opened = new RSVP.defer();
|
|
|
|
this.settings.bookPath = bookPath;
|
|
|
|
//-- Get a absolute URL from the book path
|
|
this.bookUrl = this.urlFrom(bookPath);
|
|
|
|
if(this.settings.contained || this.isContained(bookPath)){
|
|
|
|
this.settings.contained = this.contained = true;
|
|
|
|
this.bookUrl = '';
|
|
|
|
epubpackage = this.unarchive(bookPath).
|
|
then(function(){
|
|
return book.loadPackage();
|
|
});
|
|
|
|
} else {
|
|
epubpackage = this.loadPackage();
|
|
}
|
|
|
|
if(this.settings.restore && !forceReload && localStorage){
|
|
//-- Will load previous package json, or re-unpack if error
|
|
epubpackage.then(function(packageXml) {
|
|
var identifier = book.packageIdentifier(packageXml);
|
|
var restored = book.restore(identifier);
|
|
|
|
if(!restored) {
|
|
book.unpack(packageXml);
|
|
}
|
|
opened.resolve();
|
|
book.defer_opened.resolve();
|
|
});
|
|
|
|
}else{
|
|
|
|
//-- Get package information from epub opf
|
|
epubpackage.then(function(packageXml) {
|
|
book.unpack(packageXml);
|
|
opened.resolve();
|
|
book.defer_opened.resolve();
|
|
});
|
|
}
|
|
|
|
//-- If there is network connection, store the books contents
|
|
if(this.online && this.settings.storage && !this.settings.contained){
|
|
if(!this.settings.stored) opened.then(book.storeOffline());
|
|
}
|
|
|
|
this._registerReplacements(this.renderer);
|
|
|
|
return opened.promise;
|
|
|
|
};
|
|
|
|
EPUBJS.Book.prototype.loadPackage = function(_containerPath){
|
|
var book = this,
|
|
parse = new EPUBJS.Parser(),
|
|
containerPath = _containerPath || "META-INF/container.xml",
|
|
containerXml,
|
|
packageXml;
|
|
|
|
if(!this.settings.packageUrl) { //-- provide the packageUrl to skip this step
|
|
packageXml = book.loadXml(book.bookUrl + containerPath).
|
|
then(function(containerXml){
|
|
return parse.container(containerXml); // Container has path to content
|
|
}).
|
|
then(function(paths){
|
|
book.settings.contentsPath = book.bookUrl + paths.basePath;
|
|
book.settings.packageUrl = book.bookUrl + paths.packagePath;
|
|
book.settings.encoding = paths.encoding;
|
|
return book.loadXml(book.settings.packageUrl); // Containes manifest, spine and metadata
|
|
});
|
|
} else {
|
|
packageXml = book.loadXml(book.settings.packageUrl);
|
|
}
|
|
|
|
return packageXml;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.packageIdentifier = function(packageXml){
|
|
var book = this,
|
|
parse = new EPUBJS.Parser();
|
|
|
|
return parse.identifier(packageXml);
|
|
};
|
|
|
|
EPUBJS.Book.prototype.unpack = function(packageXml){
|
|
var book = this,
|
|
parse = new EPUBJS.Parser();
|
|
|
|
book.contents = parse.packageContents(packageXml, book.settings.contentsPath); // Extract info from contents
|
|
|
|
book.manifest = book.contents.manifest;
|
|
book.spine = book.contents.spine;
|
|
book.spineIndexByURL = book.contents.spineIndexByURL;
|
|
book.metadata = book.contents.metadata;
|
|
if(!book.settings.bookKey) {
|
|
book.settings.bookKey = book.generateBookKey(book.metadata.identifier);
|
|
}
|
|
|
|
//-- Set Globbal Layout setting based on metadata
|
|
book.globalLayoutProperties = book.parseLayoutProperties(book.metadata);
|
|
|
|
book.cover = book.contents.cover = book.settings.contentsPath + book.contents.coverPath;
|
|
|
|
book.spineNodeIndex = book.contents.spineNodeIndex;
|
|
|
|
book.ready.manifest.resolve(book.contents.manifest);
|
|
book.ready.spine.resolve(book.contents.spine);
|
|
book.ready.metadata.resolve(book.contents.metadata);
|
|
book.ready.cover.resolve(book.contents.cover);
|
|
|
|
|
|
//-- Load the TOC, optional; either the EPUB3 XHTML Navigation file or the EPUB2 NCX file
|
|
if(book.contents.navPath) {
|
|
book.settings.navUrl = book.settings.contentsPath + book.contents.navPath;
|
|
|
|
book.loadXml(book.settings.navUrl).
|
|
then(function(navHtml){
|
|
return parse.nav(navHtml, book.spineIndexByURL, book.spine); // Grab Table of Contents
|
|
}).then(function(toc){
|
|
book.toc = book.contents.toc = toc;
|
|
book.ready.toc.resolve(book.contents.toc);
|
|
}, function(error) {
|
|
book.ready.toc.resolve(false);
|
|
});
|
|
|
|
// Load the optional pageList
|
|
book.loadXml(book.settings.navUrl).
|
|
then(function(navHtml){
|
|
return parse.pageList(navHtml, book.spineIndexByURL, book.spine);
|
|
}).then(function(pageList){
|
|
var epubcfi = new EPUBJS.EpubCFI();
|
|
var wait = 0; // need to generate a cfi
|
|
|
|
// No pageList found
|
|
if(pageList.length === 0) {
|
|
return;
|
|
}
|
|
|
|
book.pageList = book.contents.pageList = pageList;
|
|
|
|
// Replace HREFs with CFI
|
|
book.pageList.forEach(function(pg){
|
|
if(!pg.cfi) {
|
|
wait += 1;
|
|
epubcfi.generateCfiFromHref(pg.href, book).then(function(cfi){
|
|
pg.cfi = cfi;
|
|
pg.packageUrl = book.settings.packageUrl;
|
|
|
|
wait -= 1;
|
|
if(wait === 0) {
|
|
book.pagination.process(book.pageList);
|
|
book.ready.pageList.resolve(book.pageList);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
if(!wait) {
|
|
book.pagination.process(book.pageList);
|
|
book.ready.pageList.resolve(book.pageList);
|
|
}
|
|
|
|
}, function(error) {
|
|
book.ready.pageList.resolve([]);
|
|
});
|
|
} else if(book.contents.tocPath) {
|
|
book.settings.tocUrl = book.settings.contentsPath + book.contents.tocPath;
|
|
|
|
book.loadXml(book.settings.tocUrl).
|
|
then(function(tocXml){
|
|
return parse.toc(tocXml, book.spineIndexByURL, book.spine); // Grab Table of Contents
|
|
}).then(function(toc){
|
|
book.toc = book.contents.toc = toc;
|
|
book.ready.toc.resolve(book.contents.toc);
|
|
}, function(error) {
|
|
book.ready.toc.resolve(false);
|
|
});
|
|
|
|
} else {
|
|
book.ready.toc.resolve(false);
|
|
}
|
|
|
|
};
|
|
|
|
EPUBJS.Book.prototype.createHiddenRender = function(renderer, _width, _height) {
|
|
var box = this.element.getBoundingClientRect();
|
|
var width = _width || this.settings.width || box.width;
|
|
var height = _height || this.settings.height || box.height;
|
|
var hiddenEl;
|
|
|
|
renderer.setMinSpreadWidth(this.settings.minSpreadWidth);
|
|
this._registerReplacements(renderer);
|
|
|
|
hiddenEl = document.createElement("div");
|
|
hiddenEl.style.visibility = "hidden";
|
|
hiddenEl.style.overflow = "hidden";
|
|
hiddenEl.style.width = "0";
|
|
hiddenEl.style.height = "0";
|
|
this.element.appendChild(hiddenEl);
|
|
|
|
renderer.initialize(hiddenEl, width, height);
|
|
return hiddenEl;
|
|
};
|
|
|
|
// Generates the pageList array by loading every chapter and paging through them
|
|
EPUBJS.Book.prototype.generatePageList = function(width, height){
|
|
var pageList = [];
|
|
var pager = new EPUBJS.Renderer(this.settings.render_method);
|
|
var hiddenElement = this.createHiddenRender(pager, width, height);
|
|
var deferred = new RSVP.defer();
|
|
var spinePos = -1;
|
|
var spineLength = this.spine.length;
|
|
var totalPages = 0;
|
|
var currentPage = 0;
|
|
var nextChapter = function(deferred){
|
|
var chapter;
|
|
var next = spinePos + 1;
|
|
var done = deferred || new RSVP.defer();
|
|
var loaded;
|
|
if(next >= spineLength) {
|
|
done.resolve();
|
|
} else {
|
|
spinePos = next;
|
|
chapter = new EPUBJS.Chapter(this.spine[spinePos], this.store);
|
|
|
|
pager.displayChapter(chapter, this.globalLayoutProperties).then(function(chap){
|
|
var nextPage = true;
|
|
|
|
// Page though the entire chapter
|
|
while (nextPage) {
|
|
nextPage = pager.nextPage();
|
|
}
|
|
// Load up the next chapter
|
|
nextChapter(done);
|
|
});
|
|
}
|
|
return done.promise;
|
|
}.bind(this);
|
|
|
|
var finished = nextChapter().then(function(){
|
|
pager.remove();
|
|
this.element.removeChild(hiddenElement);
|
|
deferred.resolve(pageList);
|
|
}.bind(this));
|
|
|
|
pager.on("renderer:locationChanged", function(cfi){
|
|
currentPage += 1;
|
|
pageList.push({
|
|
"cfi" : cfi,
|
|
"page" : currentPage
|
|
});
|
|
});
|
|
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
// Render out entire book and generate the pagination
|
|
// Width and Height are optional and will default to the current dimensions
|
|
EPUBJS.Book.prototype.generatePagination = function(width, height) {
|
|
var book = this;
|
|
|
|
this.ready.spine.promise.then(function(){
|
|
book.generatePageList(width, height).then(function(pageList){
|
|
book.pageList = book.contents.pageList = pageList;
|
|
book.pagination.process(pageList);
|
|
book.ready.pageList.resolve(book.pageList);
|
|
});
|
|
});
|
|
|
|
return this.pageListReady;
|
|
};
|
|
|
|
// Process the pagination from a JSON array containing the pagelist
|
|
EPUBJS.Book.prototype.loadPagination = function(pagelistJSON) {
|
|
var pageList = JSON.parse(pagelistJSON);
|
|
|
|
if(pageList && pageList.length) {
|
|
this.pageList = pageList;
|
|
this.pagination.process(this.pageList);
|
|
this.ready.pageList.resolve(this.pageList);
|
|
}
|
|
return this.pageList;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.getPageList = function() {
|
|
return this.ready.pageList.promise;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.getMetadata = function() {
|
|
return this.ready.metadata.promise;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.getToc = function() {
|
|
return this.ready.toc.promise;
|
|
};
|
|
|
|
/* Private Helpers */
|
|
|
|
//-- Listeners for browser events
|
|
EPUBJS.Book.prototype.networkListeners = function(){
|
|
var book = this;
|
|
|
|
window.addEventListener("offline", function(e) {
|
|
book.online = false;
|
|
book.trigger("book:offline");
|
|
}, false);
|
|
|
|
window.addEventListener("online", function(e) {
|
|
book.online = true;
|
|
book.trigger("book:online");
|
|
}, false);
|
|
|
|
};
|
|
|
|
// Listen to all events the renderer triggers and pass them as book events
|
|
EPUBJS.Book.prototype.listenToRenderer = function(renderer){
|
|
var book = this;
|
|
renderer.Events.forEach(function(eventName){
|
|
renderer.on(eventName, function(e){
|
|
book.trigger(eventName, e);
|
|
});
|
|
});
|
|
|
|
|
|
renderer.on("renderer:locationChanged", function(cfi) {
|
|
var page, percent;
|
|
if(this.pageList.length > 0) {
|
|
page = this.pagination.pageFromCfi(cfi);
|
|
percent = this.pagination.percentageFromPage(page);
|
|
this.trigger("book:pageChanged", {
|
|
"page": page,
|
|
"percentage": percent
|
|
});
|
|
|
|
// TODO: Add event for first and last page.
|
|
// (though last is going to be hard, since it could be several reflowed pages long)
|
|
}
|
|
}.bind(this));
|
|
|
|
renderer.on("render:loaded", this.loadChange.bind(this));
|
|
};
|
|
|
|
// Listens for load events from the Renderer and checks against the current chapter
|
|
// Prevents the Render from loading a different chapter when back button is pressed
|
|
EPUBJS.Book.prototype.loadChange = function(url){
|
|
var uri = EPUBJS.core.uri(url);
|
|
if(this.currentChapter && uri.path != this.currentChapter.absolute){
|
|
// console.warn("Miss Match", uri.path, this.currentChapter.absolute);
|
|
this.goto(uri.filename);
|
|
}
|
|
};
|
|
|
|
EPUBJS.Book.prototype.unlistenToRenderer = function(renderer){
|
|
renderer.Events.forEach(function(eventName){
|
|
renderer.off(eventName);
|
|
} );
|
|
};
|
|
|
|
//-- Choose between a request from store or a request from network
|
|
EPUBJS.Book.prototype.loadXml = function(url){
|
|
if(this.settings.fromStorage) {
|
|
return this.storage.getXml(url, this.settings.encoding);
|
|
} else if(this.settings.contained) {
|
|
return this.zip.getXml(url, this.settings.encoding);
|
|
}else{
|
|
return EPUBJS.core.request(url, 'xml', this.settings.withCredentials);
|
|
}
|
|
};
|
|
|
|
//-- Turns a url into a absolute url
|
|
EPUBJS.Book.prototype.urlFrom = function(bookPath){
|
|
var uri = EPUBJS.core.uri(bookPath),
|
|
absolute = uri.protocol,
|
|
fromRoot = uri.path[0] == "/",
|
|
location = window.location,
|
|
//-- Get URL orgin, try for native or combine
|
|
origin = location.origin || location.protocol + "//" + location.host,
|
|
baseTag = document.getElementsByTagName('base'),
|
|
base;
|
|
|
|
|
|
//-- Check is Base tag is set
|
|
|
|
if(baseTag.length) {
|
|
base = baseTag[0].href;
|
|
}
|
|
|
|
//-- 1. Check if url is absolute
|
|
if(uri.protocol){
|
|
return uri.origin + uri.path;
|
|
}
|
|
|
|
//-- 2. Check if url starts with /, add base url
|
|
if(!absolute && fromRoot){
|
|
return (base || origin) + uri.path;
|
|
}
|
|
|
|
//-- 3. Or find full path to url and add that
|
|
if(!absolute && !fromRoot){
|
|
return EPUBJS.core.resolveUrl(base || location.pathname, uri.path);
|
|
}
|
|
|
|
};
|
|
|
|
|
|
EPUBJS.Book.prototype.unarchive = function(bookPath){
|
|
var book = this,
|
|
unarchived;
|
|
|
|
//-- Must use storage
|
|
// if(this.settings.storage == false ){
|
|
// this.settings.storage = true;
|
|
// this.storage = new fileStorage.storage();
|
|
// }
|
|
|
|
this.zip = new EPUBJS.Unarchiver();
|
|
this.store = this.zip; // Use zip storaged in ram
|
|
return this.zip.openZip(bookPath);
|
|
};
|
|
|
|
//-- Checks if url has a .epub or .zip extension
|
|
EPUBJS.Book.prototype.isContained = function(bookUrl){
|
|
var uri = EPUBJS.core.uri(bookUrl);
|
|
|
|
if(uri.extension && (uri.extension == "epub" || uri.extension == "zip")){
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
//-- Checks if the book can be retrieved from localStorage
|
|
EPUBJS.Book.prototype.isSaved = function(bookKey) {
|
|
var storedSettings;
|
|
|
|
if(!localStorage) {
|
|
return false;
|
|
}
|
|
|
|
storedSettings = localStorage.getItem(bookKey);
|
|
|
|
if( !localStorage ||
|
|
storedSettings === null) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// Generates the Book Key using the identifer in the manifest or other string provided
|
|
EPUBJS.Book.prototype.generateBookKey = function(identifier){
|
|
return "epubjs:" + EPUBJS.VERSION + ":" + window.location.host + ":" + identifier;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.saveContents = function(){
|
|
if(!localStorage) {
|
|
return false;
|
|
}
|
|
localStorage.setItem(this.settings.bookKey, JSON.stringify(this.contents));
|
|
};
|
|
|
|
EPUBJS.Book.prototype.removeSavedContents = function() {
|
|
if(!localStorage) {
|
|
return false;
|
|
}
|
|
localStorage.removeItem(this.settings.bookKey);
|
|
};
|
|
|
|
|
|
|
|
//-- Takes a string or a element
|
|
EPUBJS.Book.prototype.renderTo = function(elem){
|
|
var book = this,
|
|
rendered;
|
|
|
|
if(_.isElement(elem)) {
|
|
this.element = elem;
|
|
} else if (typeof elem == "string") {
|
|
this.element = EPUBJS.core.getEl(elem);
|
|
} else {
|
|
console.error("Not an Element");
|
|
return;
|
|
}
|
|
|
|
rendered = this.opened.
|
|
then(function(){
|
|
// book.render = new EPUBJS.Renderer[this.settings.renderer](book);
|
|
book.renderer.initialize(book.element, book.settings.width, book.settings.height);
|
|
book._rendered();
|
|
return book.startDisplay();
|
|
});
|
|
|
|
// rendered.then(null, function(error) { console.error(error); });
|
|
|
|
return rendered;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.startDisplay = function(){
|
|
var display;
|
|
|
|
if(this.settings.goto) {
|
|
display = this.goto(this.settings.goto);
|
|
}else if(this.settings.previousLocationCfi) {
|
|
display = this.gotoCfi(this.settings.previousLocationCfi);
|
|
}else{
|
|
display = this.displayChapter(this.spinePos);
|
|
}
|
|
|
|
return display;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.restore = function(identifier){
|
|
|
|
var book = this,
|
|
fetch = ['manifest', 'spine', 'metadata', 'cover', 'toc', 'spineNodeIndex', 'spineIndexByURL', 'globalLayoutProperties'],
|
|
reject = false,
|
|
bookKey = this.generateBookKey(identifier),
|
|
fromStore = localStorage.getItem(bookKey),
|
|
len = fetch.length,
|
|
i;
|
|
|
|
if(this.settings.clearSaved) reject = true;
|
|
|
|
if(!reject && fromStore != 'undefined' && fromStore !== null){
|
|
book.contents = JSON.parse(fromStore);
|
|
|
|
for(i = 0; i < len; i++) {
|
|
var item = fetch[i];
|
|
|
|
if(!book.contents[item]) {
|
|
reject = true;
|
|
break;
|
|
}
|
|
book[item] = book.contents[item];
|
|
}
|
|
}
|
|
|
|
if(reject || !fromStore || !this.contents || !this.settings.contentsPath){
|
|
return false;
|
|
}else{
|
|
this.settings.bookKey = bookKey;
|
|
this.ready.manifest.resolve(this.manifest);
|
|
this.ready.spine.resolve(this.spine);
|
|
this.ready.metadata.resolve(this.metadata);
|
|
this.ready.cover.resolve(this.cover);
|
|
this.ready.toc.resolve(this.toc);
|
|
return true;
|
|
}
|
|
|
|
};
|
|
|
|
EPUBJS.Book.prototype.displayChapter = function(chap, end, deferred){
|
|
var book = this,
|
|
render,
|
|
cfi,
|
|
pos,
|
|
store,
|
|
defer = deferred || new RSVP.defer();
|
|
|
|
if(!this.isRendered) {
|
|
this._q.enqueue("displayChapter", arguments);
|
|
// Reject for now. TODO: pass promise to queue
|
|
defer.reject({
|
|
message : "Rendering",
|
|
stack : new Error().stack
|
|
});
|
|
return defer.promise;
|
|
}
|
|
|
|
if(this._rendering) {
|
|
// Pass along the current defer
|
|
this._displayQ.enqueue("displayChapter", [chap, end, defer]);
|
|
return defer.promise;
|
|
}
|
|
|
|
if(_.isNumber(chap)){
|
|
pos = chap;
|
|
}else{
|
|
cfi = new EPUBJS.EpubCFI(chap);
|
|
pos = cfi.spinePos;
|
|
}
|
|
|
|
if(pos < 0 || pos >= this.spine.length){
|
|
console.warn("Not A Valid Location");
|
|
pos = 0;
|
|
end = false;
|
|
cfi = false;
|
|
}
|
|
|
|
//-- Set the book's spine position
|
|
this.spinePos = pos;
|
|
|
|
//-- Create a new chapter
|
|
this.currentChapter = new EPUBJS.Chapter(this.spine[pos], this.store);
|
|
|
|
this._rendering = true;
|
|
|
|
render = book.renderer.displayChapter(this.currentChapter, this.globalLayoutProperties);
|
|
|
|
if(cfi) {
|
|
render.then(function(chapter){
|
|
// chapter.currentLocationCfi = chap;
|
|
chapter.gotoCfi(cfi);
|
|
defer.resolve(book.renderer);
|
|
});
|
|
} else if(end) {
|
|
render.then(function(chapter){
|
|
chapter.lastPage();
|
|
defer.resolve(book.renderer);
|
|
});
|
|
} else {
|
|
render.then(function(){
|
|
defer.resolve(book.renderer);
|
|
});
|
|
}
|
|
|
|
|
|
if(!this.settings.fromStorage &&
|
|
!this.settings.contained) {
|
|
render.then(function(){
|
|
book.preloadNextChapter();
|
|
});
|
|
}
|
|
|
|
//-- Clear render queue
|
|
render.then(function(){
|
|
var inwait;
|
|
book._rendering = false;
|
|
book._displayQ.dequeue();
|
|
});
|
|
|
|
return defer.promise;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.nextPage = function(){
|
|
var next;
|
|
|
|
if(!this.isRendered) return this._q.enqueue("nextPage", arguments);
|
|
|
|
next = this.renderer.nextPage();
|
|
|
|
if(!next){
|
|
return this.nextChapter();
|
|
}
|
|
};
|
|
|
|
EPUBJS.Book.prototype.prevPage = function() {
|
|
var prev;
|
|
|
|
if(!this.isRendered) return this._q.enqueue("prevPage", arguments);
|
|
|
|
prev = this.renderer.prevPage();
|
|
|
|
if(!prev){
|
|
return this.prevChapter();
|
|
}
|
|
};
|
|
|
|
EPUBJS.Book.prototype.nextChapter = function() {
|
|
if (this.spinePos < this.spine.length - 1) {
|
|
var next = this.spinePos + 1;
|
|
while (this.spine[next] && this.spine[next].linear && this.spine[next].linear == 'no') {
|
|
next++;
|
|
}
|
|
if (next < this.spine.length - 1) {
|
|
this.spinePos = next;
|
|
return this.displayChapter(this.spinePos);
|
|
} else {
|
|
this.trigger("book:atEnd");
|
|
}
|
|
|
|
} else {
|
|
this.trigger("book:atEnd");
|
|
}
|
|
};
|
|
|
|
EPUBJS.Book.prototype.prevChapter = function() {
|
|
if (this.spinePos > 0) {
|
|
var prev = this.spinePos - 1;
|
|
while (this.spine[prev] && this.spine[prev].linear && this.spine[prev].linear == 'no') {
|
|
prev--;
|
|
}
|
|
if (prev >= 0) {
|
|
this.spinePos = prev;
|
|
return this.displayChapter(this.spinePos, true);
|
|
} else {
|
|
this.trigger("book:atStart");
|
|
}
|
|
|
|
} else {
|
|
this.trigger("book:atStart");
|
|
}
|
|
};
|
|
|
|
EPUBJS.Book.prototype.getCurrentLocationCfi = function() {
|
|
if(!this.isRendered) return false;
|
|
return this.renderer.currentLocationCfi;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.goto = function(target){
|
|
|
|
if(target.indexOf("epubcfi(") === 0) {
|
|
return this.gotoCfi(target);
|
|
} else if(target.indexOf("%") === target.length-1) {
|
|
return this.gotoPercentage(parseInt(target.substring(0, target.length-1))/100);
|
|
} else if(typeof target === "number" || isNaN(target) === false){
|
|
return this.gotoPage(target);
|
|
} else {
|
|
return this.gotoHref(target);
|
|
}
|
|
|
|
};
|
|
|
|
EPUBJS.Book.prototype.gotoCfi = function(cfiString, defer){
|
|
var cfi,
|
|
spinePos,
|
|
spineItem,
|
|
rendered,
|
|
deferred = defer || new RSVP.defer();
|
|
|
|
if(!this.isRendered) {
|
|
this.settings.previousLocationCfi = cfiString;
|
|
return false;
|
|
}
|
|
|
|
// Currently going to a chapter
|
|
if(this._moving) {
|
|
this._gotoQ.enqueue("gotoCfi", [cfiString, deferred]);
|
|
return false;
|
|
}
|
|
|
|
cfi = new EPUBJS.EpubCFI(cfiString);
|
|
spinePos = cfi.spinePos;
|
|
|
|
if(spinePos == -1) {
|
|
return false;
|
|
}
|
|
|
|
spineItem = this.spine[spinePos];
|
|
promise = deferred.promise;
|
|
this._moving = true;
|
|
//-- If same chapter only stay on current chapter
|
|
if(this.currentChapter && this.spinePos === spinePos){
|
|
this.renderer.gotoCfi(cfi);
|
|
this._moving = false;
|
|
deferred.resolve(this.renderer.currentLocationCfi);
|
|
} else {
|
|
|
|
if(!spineItem || spinePos == -1) {
|
|
spinePos = 0;
|
|
spineItem = this.spine[spinePos];
|
|
}
|
|
|
|
this.currentChapter = new EPUBJS.Chapter(spineItem, this.store);
|
|
|
|
if(this.currentChapter) {
|
|
this.spinePos = spinePos;
|
|
render = this.renderer.displayChapter(this.currentChapter, this.globalLayoutProperties);
|
|
|
|
render.then(function(rendered){
|
|
rendered.gotoCfi(cfi);
|
|
this._moving = false;
|
|
deferred.resolve(rendered.currentLocationCfi);
|
|
}.bind(this));
|
|
}
|
|
}
|
|
|
|
promise.then(function(){
|
|
this._gotoQ.dequeue();
|
|
}.bind(this));
|
|
|
|
return promise;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.gotoHref = function(url, defer){
|
|
var split, chapter, section, absoluteURL, spinePos;
|
|
var deferred = defer || new RSVP.defer();
|
|
|
|
if(!this.isRendered) {
|
|
this.settings.goto = url;
|
|
return false;
|
|
}
|
|
|
|
// Currently going to a chapter
|
|
if(this._moving) {
|
|
this._gotoQ.enqueue("gotoHref", [url, deferred]);
|
|
return false;
|
|
}
|
|
|
|
split = url.split("#");
|
|
chapter = split[0];
|
|
section = split[1] || false;
|
|
// absoluteURL = (chapter.search("://") === -1) ? (this.settings.contentsPath + chapter) : chapter;
|
|
spinePos = this.spineIndexByURL[chapter];
|
|
|
|
//-- If link fragment only stay on current chapter
|
|
if(!chapter){
|
|
spinePos = this.currentChapter ? this.currentChapter.spinePos : 0;
|
|
}
|
|
|
|
//-- Check that URL is present in the index, or stop
|
|
if(typeof(spinePos) != "number") return false;
|
|
|
|
if(!this.currentChapter || spinePos != this.currentChapter.spinePos){
|
|
//-- Load new chapter if different than current
|
|
return this.displayChapter(spinePos).then(function(){
|
|
if(section){
|
|
this.renderer.section(section);
|
|
}
|
|
deferred.resolve(this.renderer.currentLocationCfi);
|
|
}.bind(this));
|
|
}else{
|
|
//-- Only goto section
|
|
if(section) {
|
|
this.renderer.section(section);
|
|
}
|
|
deferred.resolve(this.renderer.currentLocationCfi);
|
|
}
|
|
|
|
deferred.promise.then(function(){
|
|
this._gotoQ.dequeue();
|
|
}.bind(this));
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.gotoPage = function(pg){
|
|
var cfi = this.pagination.cfiFromPage(pg);
|
|
return this.gotoCfi(cfi);
|
|
};
|
|
|
|
EPUBJS.Book.prototype.gotoPercentage = function(percent){
|
|
var pg = this.pagination.pageFromPercentage(percent);
|
|
return this.gotoPage(pg);
|
|
};
|
|
|
|
EPUBJS.Book.prototype.preloadNextChapter = function() {
|
|
var next;
|
|
var chap = this.spinePos + 1;
|
|
|
|
if(chap >= this.spine.length){
|
|
return false;
|
|
}
|
|
|
|
next = new EPUBJS.Chapter(this.spine[chap]);
|
|
if(next) {
|
|
EPUBJS.core.request(next.absolute);
|
|
}
|
|
};
|
|
|
|
|
|
EPUBJS.Book.prototype.storeOffline = function() {
|
|
var book = this,
|
|
assets = _.values(this.manifest);
|
|
|
|
//-- Creates a queue of all items to load
|
|
return EPUBJS.storage.batch(assets).
|
|
then(function(){
|
|
book.settings.stored = true;
|
|
book.trigger("book:stored");
|
|
});
|
|
};
|
|
|
|
EPUBJS.Book.prototype.availableOffline = function() {
|
|
return this.settings.stored > 0 ? true : false;
|
|
};
|
|
|
|
/*
|
|
EPUBJS.Book.prototype.fromStorage = function(stored) {
|
|
|
|
if(this.contained) return;
|
|
|
|
if(!stored){
|
|
this.online = true;
|
|
this.tell("book:online");
|
|
}else{
|
|
if(!this.availableOffline){
|
|
//-- If book hasn't been cached yet, store offline
|
|
this.storeOffline(function(){
|
|
this.online = false;
|
|
this.tell("book:offline");
|
|
}.bind(this));
|
|
|
|
}else{
|
|
this.online = false;
|
|
this.tell("book:offline");
|
|
}
|
|
}
|
|
|
|
}
|
|
*/
|
|
|
|
EPUBJS.Book.prototype.setStyle = function(style, val, prefixed) {
|
|
if(!this.isRendered) return this._q.enqueue("setStyle", arguments);
|
|
|
|
this.settings.styles[style] = val;
|
|
|
|
this.renderer.setStyle(style, val, prefixed);
|
|
this.renderer.reformat();
|
|
};
|
|
|
|
EPUBJS.Book.prototype.removeStyle = function(style) {
|
|
if(!this.isRendered) return this._q.enqueue("removeStyle", arguments);
|
|
this.renderer.removeStyle(style);
|
|
this.renderer.reformat();
|
|
delete this.settings.styles[style];
|
|
};
|
|
|
|
EPUBJS.Book.prototype.addHeadTag = function(tag, attrs) {
|
|
if(!this.isRendered) return this._q.enqueue("addHeadTag", arguments);
|
|
this.settings.headTags[tag] = attrs;
|
|
};
|
|
|
|
EPUBJS.Book.prototype.useSpreads = function(use) {
|
|
console.warn("useSpreads is deprecated, use forceSingle or set a layoutOveride instead");
|
|
if(use === false) {
|
|
this.forceSingle(true);
|
|
} else {
|
|
this.forceSingle(false);
|
|
}
|
|
};
|
|
|
|
EPUBJS.Book.prototype.forceSingle = function(use) {
|
|
this.renderer.forceSingle(use);
|
|
if(this.isRendered) {
|
|
this.renderer.reformat();
|
|
}
|
|
};
|
|
|
|
EPUBJS.Book.prototype.unload = function(){
|
|
|
|
if(this.settings.restore && localStorage) {
|
|
this.saveContents();
|
|
}
|
|
|
|
this.unlistenToRenderer(this.renderer);
|
|
|
|
this.trigger("book:unload");
|
|
};
|
|
|
|
EPUBJS.Book.prototype.destroy = function() {
|
|
|
|
window.removeEventListener("beforeunload", this.unload);
|
|
|
|
if(this.currentChapter) this.currentChapter.unload();
|
|
|
|
this.unload();
|
|
|
|
if(this.render) this.render.remove();
|
|
|
|
};
|
|
|
|
EPUBJS.Book.prototype._ready = function() {
|
|
|
|
this.trigger("book:ready");
|
|
|
|
};
|
|
|
|
EPUBJS.Book.prototype._rendered = function(err) {
|
|
var book = this;
|
|
|
|
this.isRendered = true;
|
|
this.trigger("book:rendered");
|
|
|
|
this._q.flush();
|
|
};
|
|
|
|
|
|
EPUBJS.Book.prototype.applyStyles = function(callback){
|
|
if(!this.isRendered) return this._q.enqueue("applyStyles", arguments);
|
|
this.renderer.applyStyles(this.settings.styles);
|
|
callback();
|
|
};
|
|
|
|
EPUBJS.Book.prototype.applyHeadTags = function(callback){
|
|
if(!this.isRendered) return this._q.enqueue("applyHeadTags", arguments);
|
|
this.renderer.applyHeadTags(this.settings.headTags);
|
|
callback();
|
|
};
|
|
|
|
EPUBJS.Book.prototype._registerReplacements = function(renderer){
|
|
renderer.registerHook("beforeChapterDisplay", this.applyStyles.bind(this), true);
|
|
renderer.registerHook("beforeChapterDisplay", this.applyHeadTags.bind(this), true);
|
|
renderer.registerHook("beforeChapterDisplay", EPUBJS.replace.hrefs.bind(this), true);
|
|
|
|
if(this._needsAssetReplacement()) {
|
|
|
|
renderer.registerHook("beforeChapterDisplay", [
|
|
EPUBJS.replace.head,
|
|
EPUBJS.replace.resources,
|
|
EPUBJS.replace.svg
|
|
], true);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
EPUBJS.Book.prototype._needsAssetReplacement = function(){
|
|
if(this.settings.fromStorage) {
|
|
|
|
//-- Filesystem api links are relative, so no need to replace them
|
|
if(this.storage.getStorageType() == "filesystem") {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
|
|
} else if(this.settings.contained) {
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
};
|
|
|
|
|
|
//-- http://www.idpf.org/epub/fxl/
|
|
EPUBJS.Book.prototype.parseLayoutProperties = function(metadata){
|
|
var layout = (this.layoutOveride && this.layoutOveride.layout) || metadata.layout || "reflowable";
|
|
var spread = (this.layoutOveride && this.layoutOveride.spread) || metadata.spread || "auto";
|
|
var orientation = (this.layoutOveride && this.layoutOveride.orientation) || metadata.orientation || "auto";
|
|
return {
|
|
layout : layout,
|
|
spread : spread,
|
|
orientation : orientation
|
|
};
|
|
};
|
|
|
|
//-- Enable binding events to book
|
|
RSVP.EventTarget.mixin(EPUBJS.Book.prototype);
|
|
|
|
//-- Handle RSVP Errors
|
|
RSVP.on('error', function(event) {
|
|
//console.error(event, event.detail);
|
|
});
|
|
|
|
RSVP.configure('instrument', true); //-- true | will logging out all RSVP rejections
|
|
// RSVP.on('created', listener);
|
|
// RSVP.on('chained', listener);
|
|
// RSVP.on('fulfilled', listener);
|
|
RSVP.on('rejected', function(event){
|
|
console.error(event.detail.message, event.detail.stack);
|
|
});
|
|
|
|
EPUBJS.Chapter = function(spineObject, store){
|
|
this.href = spineObject.href;
|
|
this.absolute = spineObject.url;
|
|
this.id = spineObject.id;
|
|
this.spinePos = spineObject.index;
|
|
this.cfiBase = spineObject.cfiBase;
|
|
this.properties = spineObject.properties;
|
|
this.manifestProperties = spineObject.manifestProperties;
|
|
this.linear = spineObject.linear;
|
|
this.pages = 1;
|
|
this.store = store;
|
|
};
|
|
|
|
|
|
EPUBJS.Chapter.prototype.contents = function(_store){
|
|
var store = _store || this.store;
|
|
// if(this.store && (!this.book.online || this.book.contained))
|
|
if(store){
|
|
return store.get(href);
|
|
}else{
|
|
return EPUBJS.core.request(href, 'xml');
|
|
}
|
|
|
|
};
|
|
|
|
EPUBJS.Chapter.prototype.url = function(_store){
|
|
var deferred = new RSVP.defer();
|
|
var store = _store || this.store;
|
|
|
|
if(store){
|
|
if(!this.tempUrl) {
|
|
this.tempUrl = store.getUrl(this.absolute);
|
|
}
|
|
return this.tempUrl;
|
|
}else{
|
|
deferred.resolve(this.absolute); //-- this is less than ideal but keeps it a promise
|
|
return deferred.promise;
|
|
}
|
|
|
|
};
|
|
|
|
EPUBJS.Chapter.prototype.setPages = function(num){
|
|
this.pages = num;
|
|
};
|
|
|
|
EPUBJS.Chapter.prototype.getPages = function(num){
|
|
return this.pages;
|
|
};
|
|
|
|
EPUBJS.Chapter.prototype.getID = function(){
|
|
return this.ID;
|
|
};
|
|
|
|
EPUBJS.Chapter.prototype.unload = function(store){
|
|
|
|
if(this.tempUrl && store) {
|
|
store.revokeUrl(this.tempUrl);
|
|
this.tempUrl = false;
|
|
}
|
|
};
|
|
|
|
var EPUBJS = EPUBJS || {};
|
|
EPUBJS.core = {};
|
|
|
|
//-- Get a element for an id
|
|
EPUBJS.core.getEl = function(elem) {
|
|
return document.getElementById(elem);
|
|
};
|
|
|
|
//-- Get all elements for a class
|
|
EPUBJS.core.getEls = function(classes) {
|
|
return document.getElementsByClassName(classes);
|
|
};
|
|
|
|
EPUBJS.core.request = function(url, type, withCredentials) {
|
|
var supportsURL = window.URL;
|
|
var BLOB_RESPONSE = supportsURL ? "blob" : "arraybuffer";
|
|
|
|
var deferred = new RSVP.defer();
|
|
|
|
var xhr = new XMLHttpRequest();
|
|
|
|
//-- Check from PDF.js:
|
|
// https://github.com/mozilla/pdf.js/blob/master/web/compatibility.js
|
|
var xhrPrototype = XMLHttpRequest.prototype;
|
|
|
|
if (!('overrideMimeType' in xhrPrototype)) {
|
|
// IE10 might have response, but not overrideMimeType
|
|
Object.defineProperty(xhrPrototype, 'overrideMimeType', {
|
|
value: function xmlHttpRequestOverrideMimeType(mimeType) {}
|
|
});
|
|
}
|
|
if(withCredentials) {
|
|
xhr.withCredentials = true;
|
|
}
|
|
xhr.open("GET", url, true);
|
|
xhr.onreadystatechange = handler;
|
|
|
|
if(type == 'blob'){
|
|
xhr.responseType = BLOB_RESPONSE;
|
|
}
|
|
|
|
if(type == "json") {
|
|
xhr.setRequestHeader("Accept", "application/json");
|
|
}
|
|
|
|
if(type == 'xml') {
|
|
xhr.overrideMimeType('text/xml');
|
|
}
|
|
|
|
xhr.send();
|
|
|
|
function handler() {
|
|
if (this.readyState === this.DONE) {
|
|
if (this.status === 200 || this.responseXML ) { //-- Firefox is reporting 0 for blob urls
|
|
var r;
|
|
|
|
if(type == 'xml'){
|
|
r = this.responseXML;
|
|
}else
|
|
if(type == 'json'){
|
|
r = JSON.parse(this.response);
|
|
}else
|
|
if(type == 'blob'){
|
|
|
|
if(supportsURL) {
|
|
r = this.response;
|
|
} else {
|
|
//-- Safari doesn't support responseType blob, so create a blob from arraybuffer
|
|
r = new Blob([this.response]);
|
|
}
|
|
|
|
}else{
|
|
r = this.response;
|
|
}
|
|
|
|
deferred.resolve(r);
|
|
} else {
|
|
deferred.reject({
|
|
message : this.response,
|
|
stack : new Error().stack
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
EPUBJS.core.toArray = function(obj) {
|
|
var arr = [];
|
|
|
|
for (var member in obj) {
|
|
var newitm;
|
|
if ( obj.hasOwnProperty(member) ) {
|
|
newitm = obj[member];
|
|
newitm.ident = member;
|
|
arr.push(newitm);
|
|
}
|
|
}
|
|
|
|
return arr;
|
|
};
|
|
|
|
//-- Parse the different parts of a url, returning a object
|
|
EPUBJS.core.uri = function(url){
|
|
var uri = {
|
|
protocol : '',
|
|
host : '',
|
|
path : '',
|
|
origin : '',
|
|
directory : '',
|
|
base : '',
|
|
filename : '',
|
|
extension : '',
|
|
fragment : '',
|
|
href : url
|
|
},
|
|
doubleSlash = url.indexOf('://'),
|
|
search = url.indexOf('?'),
|
|
fragment = url.indexOf("#"),
|
|
withoutProtocol,
|
|
dot,
|
|
firstSlash;
|
|
|
|
if(fragment != -1) {
|
|
uri.fragment = url.slice(fragment + 1);
|
|
url = url.slice(0, fragment);
|
|
}
|
|
|
|
if(search != -1) {
|
|
uri.search = url.slice(search + 1);
|
|
url = url.slice(0, search);
|
|
}
|
|
|
|
if(doubleSlash != -1) {
|
|
uri.protocol = url.slice(0, doubleSlash);
|
|
withoutProtocol = url.slice(doubleSlash+3);
|
|
firstSlash = withoutProtocol.indexOf('/');
|
|
|
|
if(firstSlash === -1) {
|
|
uri.host = uri.path;
|
|
uri.path = "";
|
|
} else {
|
|
uri.host = withoutProtocol.slice(0, firstSlash);
|
|
uri.path = withoutProtocol.slice(firstSlash);
|
|
}
|
|
|
|
|
|
uri.origin = uri.protocol + "://" + uri.host;
|
|
|
|
uri.directory = EPUBJS.core.folder(uri.path);
|
|
|
|
uri.base = uri.origin + uri.directory;
|
|
// return origin;
|
|
} else {
|
|
uri.path = url;
|
|
uri.directory = EPUBJS.core.folder(url);
|
|
uri.base = uri.directory;
|
|
}
|
|
|
|
//-- Filename
|
|
uri.filename = url.replace(uri.base, '');
|
|
dot = uri.filename.lastIndexOf('.');
|
|
if(dot != -1) {
|
|
uri.extension = uri.filename.slice(dot+1);
|
|
}
|
|
return uri;
|
|
};
|
|
|
|
//-- Parse out the folder, will return everything before the last slash
|
|
|
|
EPUBJS.core.folder = function(url){
|
|
|
|
var lastSlash = url.lastIndexOf('/');
|
|
|
|
if(lastSlash == -1) var folder = '';
|
|
|
|
folder = url.slice(0, lastSlash + 1);
|
|
|
|
return folder;
|
|
|
|
};
|
|
|
|
//-- https://github.com/ebidel/filer.js/blob/master/src/filer.js#L128
|
|
EPUBJS.core.dataURLToBlob = function(dataURL) {
|
|
var BASE64_MARKER = ';base64,',
|
|
parts, contentType, raw, rawLength, uInt8Array;
|
|
|
|
if (dataURL.indexOf(BASE64_MARKER) == -1) {
|
|
parts = dataURL.split(',');
|
|
contentType = parts[0].split(':')[1];
|
|
raw = parts[1];
|
|
|
|
return new Blob([raw], {type: contentType});
|
|
}
|
|
|
|
parts = dataURL.split(BASE64_MARKER);
|
|
contentType = parts[0].split(':')[1];
|
|
raw = window.atob(parts[1]);
|
|
rawLength = raw.length;
|
|
|
|
uInt8Array = new Uint8Array(rawLength);
|
|
|
|
for (var i = 0; i < rawLength; ++i) {
|
|
uInt8Array[i] = raw.charCodeAt(i);
|
|
}
|
|
|
|
return new Blob([uInt8Array], {type: contentType});
|
|
};
|
|
|
|
//-- Load scripts async: http://stackoverflow.com/questions/7718935/load-scripts-asynchronously
|
|
EPUBJS.core.addScript = function(src, callback, target) {
|
|
var s, r;
|
|
r = false;
|
|
s = document.createElement('script');
|
|
s.type = 'text/javascript';
|
|
s.async = false;
|
|
s.src = src;
|
|
s.onload = s.onreadystatechange = function() {
|
|
if ( !r && (!this.readyState || this.readyState == 'complete') ) {
|
|
r = true;
|
|
if(callback) callback();
|
|
}
|
|
};
|
|
target = target || document.body;
|
|
target.appendChild(s);
|
|
};
|
|
|
|
EPUBJS.core.addScripts = function(srcArr, callback, target) {
|
|
var total = srcArr.length,
|
|
curr = 0,
|
|
cb = function(){
|
|
curr++;
|
|
if(total == curr){
|
|
if(callback) callback();
|
|
}else{
|
|
EPUBJS.core.addScript(srcArr[curr], cb, target);
|
|
}
|
|
};
|
|
|
|
EPUBJS.core.addScript(srcArr[curr], cb, target);
|
|
};
|
|
|
|
EPUBJS.core.addCss = function(src, callback, target) {
|
|
var s, r;
|
|
r = false;
|
|
s = document.createElement('link');
|
|
s.type = 'text/css';
|
|
s.rel = "stylesheet";
|
|
s.href = src;
|
|
s.onload = s.onreadystatechange = function() {
|
|
if ( !r && (!this.readyState || this.readyState == 'complete') ) {
|
|
r = true;
|
|
if(callback) callback();
|
|
}
|
|
};
|
|
target = target || document.body;
|
|
target.appendChild(s);
|
|
};
|
|
|
|
EPUBJS.core.prefixed = function(unprefixed) {
|
|
var vendors = ["Webkit", "Moz", "O", "ms" ],
|
|
prefixes = ['-Webkit-', '-moz-', '-o-', '-ms-'],
|
|
upper = unprefixed[0].toUpperCase() + unprefixed.slice(1),
|
|
length = vendors.length;
|
|
|
|
if (typeof(document.body.style[unprefixed]) != 'undefined') {
|
|
return unprefixed;
|
|
}
|
|
|
|
for ( var i=0; i < length; i++ ) {
|
|
if (typeof(document.body.style[vendors[i] + upper]) != 'undefined') {
|
|
return vendors[i] + upper;
|
|
}
|
|
}
|
|
|
|
return unprefixed;
|
|
};
|
|
|
|
EPUBJS.core.resolveUrl = function(base, path) {
|
|
var url,
|
|
segments = [],
|
|
uri = EPUBJS.core.uri(path),
|
|
folders = base.split("/"),
|
|
paths;
|
|
|
|
if(uri.host) {
|
|
return path;
|
|
}
|
|
|
|
folders.pop();
|
|
|
|
paths = path.split("/");
|
|
paths.forEach(function(p){
|
|
if(p === ".."){
|
|
folders.pop();
|
|
}else{
|
|
segments.push(p);
|
|
}
|
|
});
|
|
|
|
url = folders.concat(segments);
|
|
|
|
return url.join("/");
|
|
};
|
|
|
|
// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript
|
|
EPUBJS.core.uuid = function() {
|
|
var d = new Date().getTime();
|
|
var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
|
|
var r = (d + Math.random()*16)%16 | 0;
|
|
d = Math.floor(d/16);
|
|
return (c=='x' ? r : (r&0x7|0x8)).toString(16);
|
|
});
|
|
return uuid;
|
|
};
|
|
|
|
// Fast quicksort insert for sorted array -- based on:
|
|
// http://stackoverflow.com/questions/1344500/efficient-way-to-insert-a-number-into-a-sorted-array-of-numbers
|
|
EPUBJS.core.insert = function(item, array, compareFunction) {
|
|
var location = EPUBJS.core.locationOf(item, array, compareFunction);
|
|
array.splice(location, 0, item);
|
|
|
|
return location;
|
|
};
|
|
|
|
EPUBJS.core.locationOf = function(item, array, compareFunction, _start, _end) {
|
|
var start = _start || 0;
|
|
var end = _end || array.length;
|
|
var pivot = parseInt(start + (end - start) / 2);
|
|
var compared;
|
|
if(!compareFunction){
|
|
compareFunction = function(a, b) {
|
|
if(a > b) return 1;
|
|
if(a < b) return -1;
|
|
if(a = b) return 0;
|
|
};
|
|
}
|
|
if(end-start <= 0) {
|
|
return pivot;
|
|
}
|
|
|
|
compared = compareFunction(array[pivot], item);
|
|
if(end-start === 1) {
|
|
return compared > 0 ? pivot : pivot + 1;
|
|
}
|
|
|
|
if(compared === 0) {
|
|
return pivot;
|
|
}
|
|
if(compared === -1) {
|
|
return EPUBJS.core.locationOf(item, array, compareFunction, pivot, end);
|
|
} else{
|
|
return EPUBJS.core.locationOf(item, array, compareFunction, start, pivot);
|
|
}
|
|
};
|
|
|
|
EPUBJS.core.indexOfSorted = function(item, array, compareFunction, _start, _end) {
|
|
var start = _start || 0;
|
|
var end = _end || array.length;
|
|
var pivot = parseInt(start + (end - start) / 2);
|
|
var compared;
|
|
if(!compareFunction){
|
|
compareFunction = function(a, b) {
|
|
if(a > b) return 1;
|
|
if(a < b) return -1;
|
|
if(a = b) return 0;
|
|
};
|
|
}
|
|
if(end-start <= 0) {
|
|
return -1; // Not found
|
|
}
|
|
|
|
compared = compareFunction(array[pivot], item);
|
|
if(end-start === 1) {
|
|
return compared === 0 ? pivot : -1;
|
|
}
|
|
if(compared === 0) {
|
|
return pivot; // Found
|
|
}
|
|
if(compared === -1) {
|
|
return EPUBJS.core.indexOfSorted(item, array, compareFunction, pivot, end);
|
|
} else{
|
|
return EPUBJS.core.indexOfSorted(item, array, compareFunction, start, pivot);
|
|
}
|
|
};
|
|
|
|
|
|
EPUBJS.core.queue = function(_scope){
|
|
var _q = [];
|
|
var scope = _scope;
|
|
// Add an item to the queue
|
|
var enqueue = function(funcName, args, context) {
|
|
_q.push({
|
|
"funcName" : funcName,
|
|
"args" : args,
|
|
"context" : context
|
|
});
|
|
return _q;
|
|
};
|
|
// Run one item
|
|
var dequeue = function(){
|
|
var inwait;
|
|
if(_q.length) {
|
|
inwait = _q.shift();
|
|
// Defer to any current tasks
|
|
setTimeout(function(){
|
|
scope[inwait.funcName].apply(inwait.context || scope, inwait.args);
|
|
}, 0);
|
|
}
|
|
};
|
|
// Run All
|
|
var flush = function(){
|
|
while(_q.length) {
|
|
dequeue();
|
|
}
|
|
};
|
|
// Clear all items in wait
|
|
var clear = function(){
|
|
_q = [];
|
|
};
|
|
return {
|
|
"enqueue" : enqueue,
|
|
"dequeue" : dequeue,
|
|
"flush" : flush,
|
|
"clear" : clear
|
|
};
|
|
};
|
|
EPUBJS.EpubCFI = function(cfiStr){
|
|
if(cfiStr) return this.parse(cfiStr);
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.generateChapterComponent = function(_spineNodeIndex, _pos, id) {
|
|
var pos = parseInt(_pos),
|
|
spineNodeIndex = _spineNodeIndex + 1,
|
|
cfi = '/'+spineNodeIndex+'/';
|
|
|
|
cfi += (pos + 1) * 2;
|
|
|
|
if(id) cfi += "[" + id + "]";
|
|
|
|
//cfi += "!";
|
|
|
|
return cfi;
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.generatePathComponent = function(steps) {
|
|
var parts = [];
|
|
|
|
steps.forEach(function(part){
|
|
var segment = '';
|
|
segment += (part.index + 1) * 2;
|
|
|
|
if(part.id) {
|
|
segment += "[" + part.id + "]";
|
|
}
|
|
|
|
parts.push(segment);
|
|
});
|
|
|
|
return parts.join('/');
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.generateCfiFromElement = function(element, chapter) {
|
|
var steps = this.pathTo(element);
|
|
var path = this.generatePathComponent(steps);
|
|
if(!path.length) {
|
|
// Start of Chapter
|
|
return "epubcfi(" + chapter + "!/4/)";
|
|
} else {
|
|
// First Text Node
|
|
return "epubcfi(" + chapter + "!" + path + "/1:0)";
|
|
}
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.pathTo = function(node) {
|
|
var stack = [],
|
|
children;
|
|
|
|
while(node && node.parentNode !== null && node.parentNode.nodeType != 9) {
|
|
children = node.parentNode.children;
|
|
|
|
stack.unshift({
|
|
'id' : node.id,
|
|
// 'classList' : node.classList,
|
|
'tagName' : node.tagName,
|
|
'index' : children ? Array.prototype.indexOf.call(children, node) : 0
|
|
});
|
|
|
|
node = node.parentNode;
|
|
}
|
|
|
|
return stack;
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.getChapterComponent = function(cfiStr) {
|
|
|
|
var splitStr = cfiStr.split("!");
|
|
|
|
return splitStr[0];
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.getPathComponent = function(cfiStr) {
|
|
|
|
var splitStr = cfiStr.split("!");
|
|
var pathComponent = splitStr[1] ? splitStr[1].split(":") : '';
|
|
|
|
return pathComponent[0];
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.getCharecterOffsetComponent = function(cfiStr) {
|
|
var splitStr = cfiStr.split(":");
|
|
return splitStr[1] || '';
|
|
};
|
|
|
|
|
|
EPUBJS.EpubCFI.prototype.parse = function(cfiStr) {
|
|
var cfi = {},
|
|
chapSegment,
|
|
chapterComponent,
|
|
pathComponent,
|
|
charecterOffsetComponent,
|
|
assertion,
|
|
chapId,
|
|
path,
|
|
end,
|
|
endInt,
|
|
text,
|
|
parseStep = function(part){
|
|
var type, index, has_brackets, id;
|
|
|
|
type = "element";
|
|
index = parseInt(part) / 2 - 1;
|
|
has_brackets = part.match(/\[(.*)\]/);
|
|
if(has_brackets && has_brackets[1]){
|
|
id = has_brackets[1];
|
|
}
|
|
|
|
return {
|
|
"type" : type,
|
|
'index' : index,
|
|
'id' : id || false
|
|
};
|
|
};
|
|
|
|
if(typeof cfiStr !== "string") {
|
|
return {spinePos: -1};
|
|
}
|
|
|
|
cfi.str = cfiStr;
|
|
|
|
if(cfiStr.indexOf("epubcfi(") === 0) {
|
|
// Remove intial epubcfi( and ending )
|
|
cfiStr = cfiStr.slice(8, cfiStr.length-1);
|
|
}
|
|
|
|
chapterComponent = this.getChapterComponent(cfiStr);
|
|
pathComponent = this.getPathComponent(cfiStr) || '';
|
|
charecterOffsetComponent = this.getCharecterOffsetComponent(cfiStr);
|
|
// Make sure this is a valid cfi or return
|
|
if(!chapterComponent) {
|
|
return {spinePos: -1};
|
|
}
|
|
|
|
// Chapter segment is always the second one
|
|
chapSegment = chapterComponent.split("/")[2] || '';
|
|
if(!chapSegment) return {spinePos:-1};
|
|
|
|
cfi.spinePos = (parseInt(chapSegment) / 2 - 1 ) || 0;
|
|
|
|
chapId = chapSegment.match(/\[(.*)\]/);
|
|
|
|
cfi.spineId = chapId ? chapId[1] : false;
|
|
|
|
if(pathComponent.indexOf(',') != -1) {
|
|
// Handle ranges -- not supported yet
|
|
console.warn("CFI Ranges are not supported");
|
|
}
|
|
|
|
path = pathComponent.split('/');
|
|
end = path.pop();
|
|
|
|
cfi.steps = [];
|
|
|
|
path.forEach(function(part){
|
|
var step;
|
|
|
|
if(part) {
|
|
step = parseStep(part);
|
|
cfi.steps.push(step);
|
|
}
|
|
});
|
|
|
|
//-- Check if END is a text node or element
|
|
endInt = parseInt(end);
|
|
if(!isNaN(endInt)) {
|
|
|
|
if(endInt % 2 === 0) { // Even = is an element
|
|
cfi.steps.push(parseStep(end));
|
|
} else {
|
|
cfi.steps.push({
|
|
"type" : "text",
|
|
'index' : parseInt(end) - 1,
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
assertion = charecterOffsetComponent.match(/\[(.*)\]/);
|
|
if(assertion && assertion[1]){
|
|
cfi.characterOffset = parseInt(charecterOffsetComponent.split('[')[0]);
|
|
// We arent handling these assertions yet
|
|
cfi.textLocationAssertion = assertion[1];
|
|
} else {
|
|
cfi.characterOffset = parseInt(charecterOffsetComponent);
|
|
}
|
|
|
|
return cfi;
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.addMarker = function(cfi, _doc, _marker) {
|
|
var doc = _doc || document;
|
|
var marker = _marker || this.createMarker(doc);
|
|
var parent;
|
|
var lastStep;
|
|
var text;
|
|
var split;
|
|
|
|
if(typeof cfi === 'string') {
|
|
cfi = this.parse(cfi);
|
|
}
|
|
// Get the terminal step
|
|
lastStep = cfi.steps[cfi.steps.length-1];
|
|
|
|
// check spinePos
|
|
if(cfi.spinePos === -1) {
|
|
// Not a valid CFI
|
|
return false;
|
|
}
|
|
|
|
// Find the CFI elements parent
|
|
parent = this.findParent(cfi, doc);
|
|
|
|
if(!parent) {
|
|
// CFI didn't return an element
|
|
// Maybe it isnt in the current chapter?
|
|
return false;
|
|
}
|
|
|
|
if(lastStep && lastStep.type === "text") {
|
|
text = parent.childNodes[lastStep.index];
|
|
if(cfi.characterOffset){
|
|
split = text.splitText(cfi.characterOffset);
|
|
marker.classList.add("EPUBJS-CFI-SPLIT");
|
|
parent.insertBefore(marker, split);
|
|
} else {
|
|
parent.insertBefore(marker, text);
|
|
}
|
|
} else {
|
|
parent.insertBefore(marker, parent.firstChild);
|
|
}
|
|
|
|
return marker;
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.createMarker = function(_doc) {
|
|
var doc = _doc || document;
|
|
var element = doc.createElement('span');
|
|
element.id = "EPUBJS-CFI-MARKER:"+ EPUBJS.core.uuid();
|
|
element.classList.add("EPUBJS-CFI-MARKER");
|
|
|
|
return element;
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.removeMarker = function(marker, _doc) {
|
|
var doc = _doc || document;
|
|
// var id = marker.id;
|
|
|
|
// Cleanup textnodes if they were split
|
|
if(marker.classList.contains("EPUBJS-CFI-SPLIT")){
|
|
nextSib = marker.nextSibling;
|
|
prevSib = marker.previousSibling;
|
|
if(nextSib &&
|
|
prevSib &&
|
|
nextSib.nodeType === 3 &&
|
|
prevSib.nodeType === 3){
|
|
|
|
prevSib.textContent += nextSib.textContent;
|
|
marker.parentElement.removeChild(nextSib);
|
|
}
|
|
marker.parentElement.removeChild(marker);
|
|
} else if(marker.classList.contains("EPUBJS-CFI-MARKER")) {
|
|
// Remove only elements added as markers
|
|
marker.parentElement.removeChild(marker);
|
|
}
|
|
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.findParent = function(cfi, _doc) {
|
|
var doc = _doc || document,
|
|
element = doc.getElementsByTagName('html')[0],
|
|
children = Array.prototype.slice.call(element.children),
|
|
num, index, part, sections,
|
|
text, textBegin, textEnd;
|
|
|
|
if(typeof cfi === 'string') {
|
|
cfi = this.parse(cfi);
|
|
}
|
|
|
|
sections = cfi.steps.slice(0); // Clone steps array
|
|
if(!sections.length) {
|
|
return doc.getElementsByTagName('body')[0];
|
|
}
|
|
|
|
while(sections && sections.length > 0) {
|
|
part = sections.shift();
|
|
// Find textNodes Parent
|
|
if(part.type === "text") {
|
|
text = element.childNodes[part.index];
|
|
element = text.parentNode || element;
|
|
// Find element by id if present
|
|
} else if(part.id){
|
|
element = doc.getElementById(part.id);
|
|
// Find element in parent
|
|
}else{
|
|
element = children[part.index];
|
|
}
|
|
// Element can't be found
|
|
if(typeof element === "undefined") {
|
|
console.error("No Element For", part, cfi.str);
|
|
return false;
|
|
}
|
|
// Get current element children and continue through steps
|
|
children = Array.prototype.slice.call(element.children);
|
|
}
|
|
|
|
return element;
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.compare = function(cfiOne, cfiTwo) {
|
|
if(typeof cfiOne === 'string') {
|
|
cfiOne = new EPUBJS.EpubCFI(cfiOne);
|
|
}
|
|
if(typeof cfiTwo === 'string') {
|
|
cfiTwo = new EPUBJS.EpubCFI(cfiTwo);
|
|
}
|
|
// Compare Spine Positions
|
|
if(cfiOne.spinePos > cfiTwo.spinePos) {
|
|
return 1;
|
|
}
|
|
if(cfiOne.spinePos < cfiTwo.spinePos) {
|
|
return -1;
|
|
}
|
|
|
|
|
|
// Compare Each Step in the First item
|
|
for (var i = 0; i < cfiOne.steps.length; i++) {
|
|
if(!cfiTwo.steps[i]) {
|
|
return 1;
|
|
}
|
|
if(cfiOne.steps[i].index > cfiTwo.steps[i].index) {
|
|
return 1;
|
|
}
|
|
if(cfiOne.steps[i].index < cfiTwo.steps[i].index) {
|
|
return -1;
|
|
}
|
|
// Otherwise continue checking
|
|
}
|
|
|
|
// All steps in First present in Second
|
|
if(cfiOne.steps.length < cfiTwo.steps.length) {
|
|
return -1;
|
|
}
|
|
|
|
// Compare the charecter offset of the text node
|
|
if(cfiOne.characterOffset > cfiTwo.characterOffset) {
|
|
return 1;
|
|
}
|
|
if(cfiOne.characterOffset < cfiTwo.characterOffset) {
|
|
return -1;
|
|
}
|
|
|
|
// CFI's are equal
|
|
return 0;
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.generateCfiFromHref = function(href, book) {
|
|
var uri = EPUBJS.core.uri(href);
|
|
var path = uri.path;
|
|
var fragment = uri.fragment;
|
|
var spinePos = book.spineIndexByURL[path];
|
|
var loaded;
|
|
var deferred = new RSVP.defer();
|
|
var epubcfi = new EPUBJS.EpubCFI();
|
|
var spineItem;
|
|
|
|
if(typeof spinePos !== "undefined"){
|
|
spineItem = book.spine[spinePos];
|
|
loaded = book.loadXml(spineItem.url);
|
|
loaded.then(function(doc){
|
|
var element = doc.getElementById(fragment);
|
|
var cfi;
|
|
cfi = epubcfi.generateCfiFromElement(element, spineItem.cfiBase);
|
|
deferred.resolve(cfi);
|
|
});
|
|
}
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.generateCfiFromTextNode = function(anchor, offset, base) {
|
|
var parent = anchor.parentElement;
|
|
var steps = this.pathTo(parent);
|
|
var path = this.generatePathComponent(steps);
|
|
var index = [].slice.apply(parent.childNodes).indexOf(anchor) + 1;
|
|
return "epubcfi(" + base + "!" + path + "/"+index+":"+(offset || 0)+")";
|
|
};
|
|
|
|
EPUBJS.EpubCFI.prototype.generateCfiFromRangeAnchor = function(range, base) {
|
|
var anchor = range.anchorNode;
|
|
var offset = range.anchorOffset;
|
|
return this.generateCfiFromTextNode(anchor, offset, base);
|
|
};
|
|
|
|
|
|
EPUBJS.Events = function(obj, el){
|
|
|
|
this.events = {};
|
|
|
|
if(!el){
|
|
this.el = document.createElement('div');
|
|
}else{
|
|
this.el = el;
|
|
}
|
|
|
|
obj.createEvent = this.createEvent;
|
|
obj.tell = this.tell;
|
|
obj.listen = this.listen;
|
|
obj.deafen = this.deafen;
|
|
obj.listenUntil = this.listenUntil;
|
|
|
|
return this;
|
|
};
|
|
|
|
EPUBJS.Events.prototype.createEvent = function(evt){
|
|
var e = new CustomEvent(evt);
|
|
this.events[evt] = e;
|
|
return e;
|
|
};
|
|
|
|
EPUBJS.Events.prototype.tell = function(evt, msg){
|
|
var e;
|
|
|
|
if(!this.events[evt]){
|
|
console.warn("No event:", evt, "defined yet, creating.");
|
|
e = this.createEvent(evt);
|
|
}else{
|
|
e = this.events[evt];
|
|
}
|
|
|
|
if(msg) e.msg = msg;
|
|
this.el.dispatchEvent(e);
|
|
|
|
};
|
|
|
|
EPUBJS.Events.prototype.listen = function(evt, func, bindto){
|
|
if(!this.events[evt]){
|
|
console.warn("No event:", evt, "defined yet, creating.");
|
|
this.createEvent(evt);
|
|
return;
|
|
}
|
|
|
|
if(bindto){
|
|
this.el.addEventListener(evt, func.bind(bindto), false);
|
|
}else{
|
|
this.el.addEventListener(evt, func, false);
|
|
}
|
|
|
|
};
|
|
|
|
EPUBJS.Events.prototype.deafen = function(evt, func){
|
|
this.el.removeEventListener(evt, func, false);
|
|
};
|
|
|
|
EPUBJS.Events.prototype.listenUntil = function(OnEvt, OffEvt, func, bindto){
|
|
this.listen(OnEvt, func, bindto);
|
|
|
|
function unlisten(){
|
|
this.deafen(OnEvt, func);
|
|
this.deafen(OffEvt, unlisten);
|
|
}
|
|
|
|
this.listen(OffEvt, unlisten, this);
|
|
};
|
|
EPUBJS.hooks = {};
|
|
EPUBJS.Hooks = (function(){
|
|
function hooks(){}
|
|
|
|
//-- Get pre-registered hooks
|
|
hooks.prototype.getHooks = function(){
|
|
var plugs;
|
|
this.hooks = {};
|
|
Array.prototype.slice.call(arguments).forEach(function(arg){
|
|
this.hooks[arg] = [];
|
|
}, this);
|
|
|
|
for (var plugType in this.hooks) {
|
|
plugs = _.values(EPUBJS.hooks[plugType]);
|
|
|
|
plugs.forEach(function(hook){
|
|
this.registerHook(plugType, hook);
|
|
}, this);
|
|
}
|
|
};
|
|
|
|
//-- Hooks allow for injecting async functions that must all complete before continuing
|
|
// Functions must have a callback as their first argument.
|
|
hooks.prototype.registerHook = function(type, toAdd, toFront){
|
|
|
|
if(typeof(this.hooks[type]) != "undefined"){
|
|
|
|
if(typeof(toAdd) === "function"){
|
|
if(toFront) {
|
|
this.hooks[type].unshift(toAdd);
|
|
}else{
|
|
this.hooks[type].push(toAdd);
|
|
}
|
|
}else if(Array.isArray(toAdd)){
|
|
toAdd.forEach(function(hook){
|
|
if(toFront) {
|
|
this.hooks[type].unshift(hook);
|
|
}else{
|
|
this.hooks[type].push(hook);
|
|
}
|
|
}, this);
|
|
}
|
|
}else{
|
|
//-- Allows for undefined hooks, but maybe this should error?
|
|
this.hooks[type] = [func];
|
|
}
|
|
};
|
|
|
|
hooks.prototype.triggerHooks = function(type, callback, passed){
|
|
var hooks, count;
|
|
|
|
if(typeof(this.hooks[type]) == "undefined") return false;
|
|
|
|
hooks = this.hooks[type];
|
|
|
|
count = hooks.length;
|
|
|
|
if(count === 0 && callback) {
|
|
callback();
|
|
}
|
|
|
|
function countdown(){
|
|
count--;
|
|
if(count <= 0 && callback) callback();
|
|
}
|
|
|
|
hooks.forEach(function(hook){
|
|
hook(countdown, passed);
|
|
});
|
|
};
|
|
|
|
return {
|
|
register: function(name) {
|
|
if(EPUBJS.hooks[name] === undefined) { EPUBJS.hooks[name] = {}; }
|
|
if(typeof EPUBJS.hooks[name] !== 'object') { throw "Already registered: "+name; }
|
|
return EPUBJS.hooks[name];
|
|
},
|
|
mixin: function(object) {
|
|
for (var prop in hooks.prototype) {
|
|
object[prop] = hooks.prototype[prop];
|
|
}
|
|
}
|
|
};
|
|
})();
|
|
|
|
|
|
EPUBJS.Layout = EPUBJS.Layout || {};
|
|
|
|
EPUBJS.Layout.Reflowable = function(){
|
|
this.documentElement = null;
|
|
this.spreadWidth = null;
|
|
};
|
|
|
|
EPUBJS.Layout.Reflowable.prototype.format = function(documentElement, _width, _height){
|
|
// Get the prefixed CSS commands
|
|
var columnAxis = EPUBJS.core.prefixed('columnAxis');
|
|
var columnGap = EPUBJS.core.prefixed('columnGap');
|
|
var columnWidth = EPUBJS.core.prefixed('columnWidth');
|
|
|
|
//-- Check the width and create even width columns
|
|
var fullWidth = Math.floor(_width);
|
|
var width = (fullWidth % 2 === 0) ? fullWidth : fullWidth - 1;
|
|
var section = Math.floor(width / 8);
|
|
var gap = (section % 2 === 0) ? section : section - 1;
|
|
|
|
this.documentElement = documentElement;
|
|
//-- Single Page
|
|
this.spreadWidth = (width + gap);
|
|
|
|
|
|
documentElement.style.overflow = "hidden";
|
|
|
|
// Must be set to the new calculated width or the columns will be off
|
|
documentElement.style.width = width + "px";
|
|
|
|
//-- Adjust height
|
|
documentElement.style.height = _height + "px";
|
|
|
|
//-- Add columns
|
|
documentElement.style[columnAxis] = "horizontal";
|
|
documentElement.style[columnGap] = gap+"px";
|
|
documentElement.style[columnWidth] = width+"px";
|
|
|
|
return {
|
|
pageWidth : this.spreadWidth,
|
|
pageHeight : _height
|
|
};
|
|
};
|
|
|
|
EPUBJS.Layout.Reflowable.prototype.calculatePages = function() {
|
|
var totalWidth, displayedPages;
|
|
this.documentElement.style.width = "auto"; //-- reset width for calculations
|
|
totalWidth = this.documentElement.scrollWidth;
|
|
displayedPages = Math.ceil(totalWidth / this.spreadWidth);
|
|
|
|
return {
|
|
displayedPages : displayedPages,
|
|
pageCount : displayedPages
|
|
};
|
|
};
|
|
|
|
EPUBJS.Layout.ReflowableSpreads = function(){
|
|
this.documentElement = null;
|
|
this.spreadWidth = null;
|
|
};
|
|
|
|
EPUBJS.Layout.ReflowableSpreads.prototype.format = function(documentElement, _width, _height){
|
|
var columnAxis = EPUBJS.core.prefixed('columnAxis');
|
|
var columnGap = EPUBJS.core.prefixed('columnGap');
|
|
var columnWidth = EPUBJS.core.prefixed('columnWidth');
|
|
|
|
var divisor = 2,
|
|
cutoff = 800;
|
|
|
|
//-- Check the width and create even width columns
|
|
var fullWidth = Math.floor(_width);
|
|
var width = (fullWidth % 2 === 0) ? fullWidth : fullWidth - 1;
|
|
var section = Math.floor(width / 8);
|
|
var gap = (section % 2 === 0) ? section : section - 1;
|
|
//-- Double Page
|
|
var colWidth = Math.floor((width - gap) / divisor);
|
|
|
|
this.documentElement = documentElement;
|
|
this.spreadWidth = (colWidth + gap) * divisor;
|
|
|
|
|
|
documentElement.style.overflow = "hidden";
|
|
|
|
// Must be set to the new calculated width or the columns will be off
|
|
documentElement.style.width = width + "px";
|
|
|
|
//-- Adjust height
|
|
documentElement.style.height = _height + "px";
|
|
|
|
//-- Add columns
|
|
documentElement.style[columnAxis] = "horizontal";
|
|
documentElement.style[columnGap] = gap+"px";
|
|
documentElement.style[columnWidth] = colWidth+"px";
|
|
|
|
return {
|
|
pageWidth : this.spreadWidth,
|
|
pageHeight : _height
|
|
};
|
|
};
|
|
|
|
EPUBJS.Layout.ReflowableSpreads.prototype.calculatePages = function() {
|
|
var totalWidth = this.documentElement.scrollWidth;
|
|
var displayedPages = Math.ceil(totalWidth / this.spreadWidth);
|
|
|
|
//-- Add a page to the width of the document to account an for odd number of pages
|
|
this.documentElement.style.width = totalWidth + this.spreadWidth + "px";
|
|
return {
|
|
displayedPages : displayedPages,
|
|
pageCount : displayedPages * 2
|
|
};
|
|
};
|
|
|
|
EPUBJS.Layout.Fixed = function(){
|
|
this.documentElement = null;
|
|
};
|
|
|
|
EPUBJS.Layout.Fixed = function(documentElement, _width, _height){
|
|
var columnWidth = EPUBJS.core.prefixed('columnWidth');
|
|
var viewport = documentElement.querySelector("[name=viewport");
|
|
var content;
|
|
var contents;
|
|
var width, height;
|
|
|
|
this.documentElement = documentElement;
|
|
/**
|
|
* check for the viewport size
|
|
* <meta name="viewport" content="width=1024,height=697" />
|
|
*/
|
|
if(viewport && viewport.hasAttribute("content")) {
|
|
content = viewport.getAttribute("content");
|
|
contents = content.split(',');
|
|
if(contents[0]){
|
|
width = contents[0].replace("width=", '');
|
|
}
|
|
if(contents[1]){
|
|
height = contents[1].replace("height=", '');
|
|
}
|
|
}
|
|
|
|
//-- Adjust width and height
|
|
documentElement.style.width = width + "px" || "auto";
|
|
documentElement.style.height = height + "px" || "auto";
|
|
|
|
//-- Remove columns
|
|
documentElement.style[columnWidth] = "auto";
|
|
|
|
//-- Scroll
|
|
documentElement.style.overflow = "auto";
|
|
|
|
|
|
return {
|
|
pageWidth : width,
|
|
pageHeight : height
|
|
};
|
|
|
|
};
|
|
|
|
EPUBJS.Layout.Fixed.prototype.calculatePages = function(){
|
|
return {
|
|
displayedPages : 1,
|
|
pageCount : 1
|
|
};
|
|
};
|
|
EPUBJS.Pagination = function(pageList) {
|
|
this.pages = [];
|
|
this.locations = [];
|
|
this.epubcfi = new EPUBJS.EpubCFI();
|
|
if(pageList && pageList.length) {
|
|
this.process(pageList);
|
|
}
|
|
};
|
|
|
|
EPUBJS.Pagination.prototype.process = function(pageList){
|
|
pageList.forEach(function(item){
|
|
this.pages.push(item.page);
|
|
this.locations.push(item.cfi);
|
|
}, this);
|
|
|
|
this.pageList = pageList;
|
|
this.firstPage = parseInt(this.pages[0]);
|
|
this.lastPage = parseInt(this.pages[this.pages.length-1]);
|
|
this.totalPages = this.lastPage - this.firstPage;
|
|
};
|
|
|
|
EPUBJS.Pagination.prototype.pageFromCfi = function(cfi){
|
|
var pg = -1;
|
|
|
|
// Check if the pageList has not been set yet
|
|
if(this.locations.length === 0) {
|
|
return -1;
|
|
}
|
|
|
|
// TODO: check if CFI is valid?
|
|
|
|
// check if the cfi is in the location list
|
|
// var index = this.locations.indexOf(cfi);
|
|
var index = EPUBJS.core.indexOfSorted(cfi, this.locations, this.epubcfi.compare);
|
|
if(index != -1 && index < (this.pages.length-1) ) {
|
|
pg = this.pages[index];
|
|
} else {
|
|
// Otherwise add it to the list of locations
|
|
// Insert it in the correct position in the locations page
|
|
index = EPUBJS.core.insert(cfi, this.locations, this.epubcfi.compare);
|
|
// Get the page at the location just before the new one, or return the first
|
|
pg = index-1 >= 0 ? this.pages[index-1] : this.pages[0];
|
|
if(pg !== undefined) {
|
|
// Add the new page in so that the locations and page array match up
|
|
this.pages.splice(index, 0, pg);
|
|
} else {
|
|
pg = -1;
|
|
}
|
|
|
|
}
|
|
return pg;
|
|
};
|
|
|
|
EPUBJS.Pagination.prototype.cfiFromPage = function(pg){
|
|
var cfi = -1;
|
|
// check that pg is an int
|
|
if(typeof pg != "number"){
|
|
pg = parseInt(pg);
|
|
}
|
|
|
|
// check if the cfi is in the page list
|
|
// Pages could be unsorted.
|
|
var index = this.pages.indexOf(pg);
|
|
if(index != -1) {
|
|
cfi = this.locations[index];
|
|
}
|
|
// TODO: handle pages not in the list
|
|
return cfi;
|
|
};
|
|
|
|
EPUBJS.Pagination.prototype.pageFromPercentage = function(percent){
|
|
var pg = Math.round(this.totalPages * percent);
|
|
return pg;
|
|
};
|
|
|
|
// Returns a value between 0 - 1 corresponding to the location of a page
|
|
EPUBJS.Pagination.prototype.percentageFromPage = function(pg){
|
|
var percentage = (pg - this.firstPage) / this.totalPages;
|
|
return Math.round(percentage * 1000) / 1000;
|
|
};
|
|
|
|
// Returns a value between 0 - 1 corresponding to the location of a cfi
|
|
EPUBJS.Pagination.prototype.percentageFromCfi = function(cfi){
|
|
var pg = this.pageFromCfi(cfi);
|
|
var percentage = this.percentageFromPage(pg);
|
|
return percentage;
|
|
};
|
|
EPUBJS.Parser = function(baseUrl){
|
|
this.baseUrl = baseUrl || '';
|
|
};
|
|
|
|
EPUBJS.Parser.prototype.container = function(containerXml){
|
|
//-- <rootfile full-path="OPS/package.opf" media-type="application/oebps-package+xml"/>
|
|
var rootfile, fullpath, folder, encoding;
|
|
|
|
if(!containerXml) {
|
|
console.error("Container File Not Found");
|
|
return;
|
|
}
|
|
|
|
rootfile = containerXml.querySelector("rootfile");
|
|
|
|
if(!rootfile) {
|
|
console.error("No RootFile Found");
|
|
return;
|
|
}
|
|
|
|
fullpath = rootfile.getAttribute('full-path');
|
|
folder = EPUBJS.core.uri(fullpath).directory;
|
|
encoding = containerXml.xmlEncoding;
|
|
|
|
//-- Now that we have the path we can parse the contents
|
|
return {
|
|
'packagePath' : fullpath,
|
|
'basePath' : folder,
|
|
'encoding' : encoding
|
|
};
|
|
};
|
|
|
|
EPUBJS.Parser.prototype.identifier = function(packageXml){
|
|
var metadataNode;
|
|
|
|
if(!packageXml) {
|
|
console.error("Package File Not Found");
|
|
return;
|
|
}
|
|
|
|
metadataNode = packageXml.querySelector("metadata");
|
|
|
|
if(!metadataNode) {
|
|
console.error("No Metadata Found");
|
|
return;
|
|
}
|
|
|
|
return this.getElementText(metadataNode, "identifier");
|
|
};
|
|
|
|
EPUBJS.Parser.prototype.packageContents = function(packageXml, baseUrl){
|
|
var parse = this;
|
|
var metadataNode, manifestNode, spineNode;
|
|
var manifest, navPath, tocPath, coverPath;
|
|
var spineNodeIndex;
|
|
var spine;
|
|
var spineIndexByURL;
|
|
|
|
if(baseUrl) this.baseUrl = baseUrl;
|
|
|
|
if(!packageXml) {
|
|
console.error("Package File Not Found");
|
|
return;
|
|
}
|
|
|
|
metadataNode = packageXml.querySelector("metadata");
|
|
if(!metadataNode) {
|
|
console.error("No Metadata Found");
|
|
return;
|
|
}
|
|
|
|
manifestNode = packageXml.querySelector("manifest");
|
|
if(!manifestNode) {
|
|
console.error("No Manifest Found");
|
|
return;
|
|
}
|
|
|
|
spineNode = packageXml.querySelector("spine");
|
|
if(!spineNode) {
|
|
console.error("No Spine Found");
|
|
return;
|
|
}
|
|
|
|
manifest = parse.manifest(manifestNode);
|
|
navPath = parse.findNavPath(manifestNode);
|
|
tocPath = parse.findTocPath(manifestNode);
|
|
coverPath = parse.findCoverPath(manifestNode);
|
|
|
|
spineNodeIndex = Array.prototype.indexOf.call(spineNode.parentNode.childNodes, spineNode);
|
|
|
|
spine = parse.spine(spineNode, manifest);
|
|
|
|
spineIndexByURL = {};
|
|
spine.forEach(function(item){
|
|
spineIndexByURL[item.href] = item.index;
|
|
});
|
|
|
|
return {
|
|
'metadata' : parse.metadata(metadataNode),
|
|
'spine' : spine,
|
|
'manifest' : manifest,
|
|
'navPath' : navPath,
|
|
'tocPath' : tocPath,
|
|
'coverPath': coverPath,
|
|
'spineNodeIndex' : spineNodeIndex,
|
|
'spineIndexByURL' : spineIndexByURL
|
|
};
|
|
};
|
|
|
|
//-- Find TOC NAV: media-type="application/xhtml+xml" href="toc.ncx"
|
|
EPUBJS.Parser.prototype.findNavPath = function(manifestNode){
|
|
var node = manifestNode.querySelector("item[properties^='nav']");
|
|
return node ? node.getAttribute('href') : false;
|
|
};
|
|
|
|
//-- Find TOC NCX: media-type="application/x-dtbncx+xml" href="toc.ncx"
|
|
EPUBJS.Parser.prototype.findTocPath = function(manifestNode){
|
|
var node = manifestNode.querySelector("item[media-type='application/x-dtbncx+xml']");
|
|
return node ? node.getAttribute('href') : false;
|
|
};
|
|
|
|
//-- Find Cover: <item properties="cover-image" id="ci" href="cover.svg" media-type="image/svg+xml" />
|
|
EPUBJS.Parser.prototype.findCoverPath = function(manifestNode){
|
|
var node = manifestNode.querySelector("item[properties='cover-image']");
|
|
return node ? node.getAttribute('href') : false;
|
|
};
|
|
|
|
//-- Expanded to match Readium web components
|
|
EPUBJS.Parser.prototype.metadata = function(xml){
|
|
var metadata = {},
|
|
p = this;
|
|
|
|
metadata.bookTitle = p.getElementText(xml, 'title');
|
|
metadata.creator = p.getElementText(xml, 'creator');
|
|
metadata.description = p.getElementText(xml, 'description');
|
|
|
|
metadata.pubdate = p.getElementText(xml, 'date');
|
|
|
|
metadata.publisher = p.getElementText(xml, 'publisher');
|
|
|
|
metadata.identifier = p.getElementText(xml, "identifier");
|
|
metadata.language = p.getElementText(xml, "language");
|
|
metadata.rights = p.getElementText(xml, "rights");
|
|
|
|
metadata.modified_date = p.querySelectorText(xml, "meta[property='dcterms:modified']");
|
|
metadata.layout = p.querySelectorText(xml, "meta[property='rendition:layout']");
|
|
metadata.orientation = p.querySelectorText(xml, "meta[property='rendition:orientation']");
|
|
metadata.spread = p.querySelectorText(xml, "meta[property='rendition:spread']");
|
|
// metadata.page_prog_dir = packageXml.querySelector("spine").getAttribute("page-progression-direction");
|
|
|
|
return metadata;
|
|
};
|
|
|
|
EPUBJS.Parser.prototype.getElementText = function(xml, tag){
|
|
var found = xml.getElementsByTagNameNS("http://purl.org/dc/elements/1.1/", tag),
|
|
el;
|
|
|
|
if(!found || found.length === 0) return '';
|
|
|
|
el = found[0];
|
|
|
|
if(el.childNodes.length){
|
|
return el.childNodes[0].nodeValue;
|
|
}
|
|
|
|
return '';
|
|
|
|
};
|
|
|
|
EPUBJS.Parser.prototype.querySelectorText = function(xml, q){
|
|
var el = xml.querySelector(q);
|
|
|
|
if(el && el.childNodes.length){
|
|
return el.childNodes[0].nodeValue;
|
|
}
|
|
|
|
return '';
|
|
};
|
|
|
|
EPUBJS.Parser.prototype.manifest = function(manifestXml){
|
|
var baseUrl = this.baseUrl,
|
|
manifest = {};
|
|
|
|
//-- Turn items into an array
|
|
var selected = manifestXml.querySelectorAll("item"),
|
|
items = Array.prototype.slice.call(selected);
|
|
|
|
//-- Create an object with the id as key
|
|
items.forEach(function(item){
|
|
var id = item.getAttribute('id'),
|
|
href = item.getAttribute('href') || '',
|
|
type = item.getAttribute('media-type') || '',
|
|
properties = item.getAttribute('properties') || '';
|
|
|
|
manifest[id] = {
|
|
'href' : href,
|
|
'url' : baseUrl + href, //-- Absolute URL for loading with a web worker
|
|
'type' : type,
|
|
'properties' : properties
|
|
};
|
|
|
|
});
|
|
|
|
return manifest;
|
|
|
|
};
|
|
|
|
EPUBJS.Parser.prototype.spine = function(spineXml, manifest){
|
|
var spine = [];
|
|
|
|
var selected = spineXml.getElementsByTagName("itemref"),
|
|
items = Array.prototype.slice.call(selected);
|
|
|
|
var spineNodeIndex = Array.prototype.indexOf.call(spineXml.parentNode.childNodes, spineXml);
|
|
|
|
var epubcfi = new EPUBJS.EpubCFI();
|
|
|
|
//-- Add to array to mantain ordering and cross reference with manifest
|
|
items.forEach(function(item, index){
|
|
var Id = item.getAttribute('idref');
|
|
var cfiBase = epubcfi.generateChapterComponent(spineNodeIndex, index, Id);
|
|
var props = item.getAttribute('properties') || '';
|
|
var propArray = props.length ? props.split(' ') : [];
|
|
var manifestProps = manifest[Id].properties;
|
|
var manifestPropArray = manifestProps.length ? manifestProps.split(' ') : [];
|
|
var vert = {
|
|
'id' : Id,
|
|
'linear' : item.getAttribute('linear') || '',
|
|
'properties' : propArray,
|
|
'manifestProperties' : manifestPropArray,
|
|
'href' : manifest[Id].href,
|
|
'url' : manifest[Id].url,
|
|
'index' : index,
|
|
'cfiBase' : cfiBase
|
|
};
|
|
spine.push(vert);
|
|
});
|
|
|
|
return spine;
|
|
};
|
|
|
|
EPUBJS.Parser.prototype.nav = function(navHtml, spineIndexByURL, bookSpine){
|
|
var navEl = navHtml.querySelector('nav[*|type="toc"]'), //-- [*|type="toc"] * Doesn't seem to work
|
|
idCounter = 0;
|
|
|
|
if(!navEl) return [];
|
|
|
|
// Implements `> ol > li`
|
|
function findListItems(parent){
|
|
var items = [];
|
|
|
|
Array.prototype.slice.call(parent.childNodes).forEach(function(node){
|
|
if('ol' == node.tagName){
|
|
Array.prototype.slice.call(node.childNodes).forEach(function(item){
|
|
if('li' == item.tagName){
|
|
items.push(item);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
return items;
|
|
|
|
}
|
|
|
|
// Implements `> a, > span`
|
|
function findAnchorOrSpan(parent){
|
|
var item = null;
|
|
|
|
Array.prototype.slice.call(parent.childNodes).forEach(function(node){
|
|
if('a' == node.tagName || 'span' == node.tagName){
|
|
item = node;
|
|
}
|
|
});
|
|
|
|
return item;
|
|
}
|
|
|
|
function getTOC(parent){
|
|
var list = [],
|
|
nodes = findListItems(parent),
|
|
items = Array.prototype.slice.call(nodes),
|
|
length = items.length,
|
|
node;
|
|
|
|
if(length === 0) return false;
|
|
|
|
items.forEach(function(item){
|
|
var id = item.getAttribute('id') || false,
|
|
content = findAnchorOrSpan(item),
|
|
href = content.getAttribute('href') || '',
|
|
text = content.textContent || "",
|
|
split = href.split("#"),
|
|
baseUrl = split[0],
|
|
subitems = getTOC(item),
|
|
spinePos = spineIndexByURL[baseUrl],
|
|
spineItem;
|
|
|
|
if(!id) {
|
|
if(spinePos) {
|
|
spineItem = bookSpine[spinePos];
|
|
id = spineItem.id;
|
|
} else {
|
|
id = 'epubjs-autogen-toc-id-' + (idCounter++);
|
|
}
|
|
}
|
|
|
|
item.setAttribute('id', id); // Ensure all elements have an id
|
|
list.push({
|
|
"id": id,
|
|
"href": href,
|
|
"label": text,
|
|
"subitems" : subitems,
|
|
"parent" : parent ? parent.getAttribute('id') : null
|
|
});
|
|
|
|
});
|
|
|
|
return list;
|
|
}
|
|
|
|
return getTOC(navEl);
|
|
};
|
|
|
|
EPUBJS.Parser.prototype.toc = function(tocXml, spineIndexByURL, bookSpine){
|
|
var navMap = tocXml.querySelector("navMap");
|
|
if(!navMap) return [];
|
|
|
|
function getTOC(parent){
|
|
var list = [],
|
|
nodes = parent.querySelectorAll("navPoint"),
|
|
items = Array.prototype.slice.call(nodes).reverse(),
|
|
length = items.length,
|
|
iter = length,
|
|
node;
|
|
|
|
if(length === 0) return [];
|
|
|
|
items.forEach(function(item){
|
|
var id = item.getAttribute('id') || false,
|
|
content = item.querySelector("content"),
|
|
src = content.getAttribute('src'),
|
|
navLabel = item.querySelector("navLabel"),
|
|
text = navLabel.textContent ? navLabel.textContent : "",
|
|
split = src.split("#"),
|
|
baseUrl = split[0],
|
|
spinePos = spineIndexByURL[baseUrl],
|
|
spineItem,
|
|
subitems = getTOC(item);
|
|
|
|
if(!id) {
|
|
if(spinePos) {
|
|
spineItem = bookSpine[spinePos];
|
|
id = spineItem.id;
|
|
} else {
|
|
id = 'epubjs-autogen-toc-id-' + (idCounter++);
|
|
}
|
|
}
|
|
|
|
|
|
list.unshift({
|
|
"id": id,
|
|
"href": src,
|
|
"label": text,
|
|
"spinePos": spinePos,
|
|
"subitems" : subitems,
|
|
"parent" : parent ? parent.getAttribute('id') : null
|
|
});
|
|
|
|
});
|
|
|
|
return list;
|
|
}
|
|
|
|
return getTOC(navMap);
|
|
};
|
|
|
|
EPUBJS.Parser.prototype.pageList = function(navHtml, spineIndexByURL, bookSpine){
|
|
var navEl = navHtml.querySelector('nav[*|type="page-list"]'),
|
|
idCounter = 0;
|
|
|
|
if(!navEl) return [];
|
|
|
|
// Implements `> ol > li`
|
|
function findListItems(parent){
|
|
var items = [];
|
|
|
|
Array.prototype.slice.call(parent.childNodes).forEach(function(node){
|
|
if('ol' == node.tagName){
|
|
Array.prototype.slice.call(node.childNodes).forEach(function(item){
|
|
if('li' == item.tagName){
|
|
items.push(item);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
return items;
|
|
|
|
}
|
|
|
|
// Implements `> a, > span`
|
|
function findAnchorOrSpan(parent){
|
|
var item = null;
|
|
|
|
Array.prototype.slice.call(parent.childNodes).forEach(function(node){
|
|
if('a' == node.tagName || 'span' == node.tagName){
|
|
item = node;
|
|
}
|
|
});
|
|
|
|
return item;
|
|
}
|
|
|
|
function getPages(parent){
|
|
var list = [],
|
|
nodes = findListItems(parent),
|
|
items = Array.prototype.slice.call(nodes),
|
|
length = items.length,
|
|
node;
|
|
|
|
if(length === 0) return false;
|
|
|
|
items.forEach(function(item){
|
|
var id = item.getAttribute('id') || false,
|
|
content = findAnchorOrSpan(item),
|
|
href = content.getAttribute('href') || '',
|
|
text = content.textContent || "",
|
|
page = parseInt(text),
|
|
isCfi = href.indexOf("epubcfi"),
|
|
split,
|
|
packageUrl,
|
|
cfi;
|
|
|
|
if(isCfi != -1) {
|
|
split = href.split("#");
|
|
packageUrl = split[0];
|
|
cfi = split.length > 1 ? split[1] : false;
|
|
list.push({
|
|
"cfi" : cfi,
|
|
"href" : href,
|
|
"packageUrl" : packageUrl,
|
|
"page" : page
|
|
});
|
|
} else {
|
|
list.push({
|
|
"href" : href,
|
|
"page" : page
|
|
});
|
|
}
|
|
|
|
});
|
|
|
|
return list;
|
|
}
|
|
|
|
return getPages(navEl);
|
|
};
|
|
|
|
EPUBJS.Render.Iframe = function() {
|
|
this.iframe = null;
|
|
this.document = null;
|
|
this.window = null;
|
|
this.docEl = null;
|
|
this.bodyEl = null;
|
|
|
|
this.leftPos = 0;
|
|
this.pageWidth = 0;
|
|
};
|
|
|
|
//-- Build up any html needed
|
|
EPUBJS.Render.Iframe.prototype.create = function(){
|
|
this.iframe = document.createElement('iframe');
|
|
this.iframe.id = "epubjs-iframe:" + EPUBJS.core.uuid();
|
|
this.iframe.scrolling = "no";
|
|
this.iframe.seamless = "seamless";
|
|
// Back up if seamless isn't supported
|
|
this.iframe.style.border = "none";
|
|
|
|
this.iframe.addEventListener("load", this.loaded.bind(this), false);
|
|
return this.iframe;
|
|
};
|
|
|
|
/**
|
|
* Sets the source of the iframe with the given URL string
|
|
* Takes: URL string
|
|
* Returns: promise with document element
|
|
*/
|
|
EPUBJS.Render.Iframe.prototype.load = function(url){
|
|
var render = this,
|
|
deferred = new RSVP.defer();
|
|
|
|
this.iframe.src = url;
|
|
|
|
// Reset the scroll position
|
|
render.leftPos = 0;
|
|
|
|
if(this.window) {
|
|
this.unload();
|
|
}
|
|
|
|
this.iframe.onload = function() {
|
|
render.document = render.iframe.contentDocument;
|
|
|
|
render.docEl = render.document.documentElement;
|
|
render.headEl = render.document.head;
|
|
render.bodyEl = render.document.body;
|
|
render.window = render.iframe.contentWindow;
|
|
|
|
render.window.addEventListener("resize", render.resized.bind(render), false);
|
|
|
|
//-- Clear Margins
|
|
if(render.bodyEl) {
|
|
render.bodyEl.style.margin = "0";
|
|
}
|
|
|
|
deferred.resolve(render.docEl);
|
|
};
|
|
|
|
this.iframe.onerror = function(e) {
|
|
//console.error("Error Loading Contents", e);
|
|
deferred.reject({
|
|
message : "Error Loading Contents: " + e,
|
|
stack : new Error().stack
|
|
});
|
|
};
|
|
return deferred.promise;
|
|
};
|
|
|
|
|
|
EPUBJS.Render.Iframe.prototype.loaded = function(v){
|
|
var url = this.iframe.contentWindow.location.href;
|
|
this.trigger("render:loaded", url);
|
|
};
|
|
|
|
// Resize the iframe to the given width and height
|
|
EPUBJS.Render.Iframe.prototype.resize = function(width, height){
|
|
var iframeBox;
|
|
|
|
if(!this.iframe) return;
|
|
|
|
this.iframe.height = height;
|
|
|
|
if(!isNaN(width) && width % 2 !== 0){
|
|
width += 1; //-- Prevent cutting off edges of text in columns
|
|
}
|
|
|
|
this.iframe.width = width;
|
|
// Get the fractional height and width of the iframe
|
|
// Default to orginal if bounding rect is 0
|
|
this.width = this.iframe.getBoundingClientRect().width || width;
|
|
this.height = this.iframe.getBoundingClientRect().height || height;
|
|
};
|
|
|
|
|
|
EPUBJS.Render.Iframe.prototype.resized = function(e){
|
|
// Get the fractional height and width of the iframe
|
|
this.width = this.iframe.getBoundingClientRect().width;
|
|
this.height = this.iframe.getBoundingClientRect().height;
|
|
};
|
|
|
|
EPUBJS.Render.Iframe.prototype.totalWidth = function(){
|
|
return this.docEl.scrollWidth;
|
|
};
|
|
|
|
EPUBJS.Render.Iframe.prototype.totalHeight = function(){
|
|
return this.docEl.scrollHeight;
|
|
};
|
|
|
|
EPUBJS.Render.Iframe.prototype.setPageDimensions = function(pageWidth, pageHeight){
|
|
this.pageWidth = pageWidth;
|
|
this.pageHeight = pageHeight;
|
|
//-- Add a page to the width of the document to account an for odd number of pages
|
|
// this.docEl.style.width = this.docEl.scrollWidth + pageWidth + "px";
|
|
};
|
|
|
|
EPUBJS.Render.Iframe.prototype.setLeft = function(leftPos){
|
|
// this.bodyEl.style.marginLeft = -leftPos + "px";
|
|
// this.docEl.style.marginLeft = -leftPos + "px";
|
|
// this.docEl.style[EPUBJS.Render.Iframe.transform] = 'translate('+ (-leftPos) + 'px, 0)';
|
|
this.document.defaultView.scrollTo(leftPos, 0);
|
|
};
|
|
|
|
EPUBJS.Render.Iframe.prototype.setStyle = function(style, val, prefixed){
|
|
if(prefixed) {
|
|
style = EPUBJS.core.prefixed(style);
|
|
}
|
|
|
|
if(this.bodyEl) this.bodyEl.style[style] = val;
|
|
};
|
|
|
|
EPUBJS.Render.Iframe.prototype.removeStyle = function(style){
|
|
|
|
if(this.bodyEl) this.bodyEl.style[style] = '';
|
|
|
|
};
|
|
|
|
EPUBJS.Render.Iframe.prototype.addHeadTag = function(tag, attrs) {
|
|
var tagEl = document.createElement(tag);
|
|
|
|
for(var attr in attrs) {
|
|
tagEl[attr] = attrs[attr];
|
|
}
|
|
|
|
if(this.headEl) this.headEl.appendChild(tagEl);
|
|
};
|
|
|
|
EPUBJS.Render.Iframe.prototype.page = function(pg){
|
|
this.leftPos = this.pageWidth * (pg-1); //-- pages start at 1
|
|
this.setLeft(this.leftPos);
|
|
};
|
|
|
|
//-- Show the page containing an Element
|
|
EPUBJS.Render.Iframe.prototype.getPageNumberByElement = function(el){
|
|
var left, pg;
|
|
if(!el) return;
|
|
|
|
left = this.leftPos + el.getBoundingClientRect().left; //-- Calculate left offset compaired to scrolled position
|
|
|
|
pg = Math.floor(left / this.pageWidth) + 1; //-- pages start at 1
|
|
|
|
return pg;
|
|
};
|
|
|
|
// Return the root element of the content
|
|
EPUBJS.Render.Iframe.prototype.getBaseElement = function(){
|
|
return this.bodyEl;
|
|
};
|
|
|
|
// Checks if an element is on the screen
|
|
EPUBJS.Render.Iframe.prototype.isElementVisible = function(el){
|
|
var rect;
|
|
var left;
|
|
|
|
if(el && typeof el.getBoundingClientRect === 'function'){
|
|
rect = el.getBoundingClientRect();
|
|
left = rect.left; //+ rect.width;
|
|
if( rect.width !== 0 &&
|
|
rect.height !== 0 && // Element not visible
|
|
left >= 0 &&
|
|
left < this.pageWidth ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
|
|
EPUBJS.Render.Iframe.prototype.scroll = function(bool){
|
|
if(bool) {
|
|
this.iframe.scrolling = "yes";
|
|
} else {
|
|
this.iframe.scrolling = "no";
|
|
}
|
|
};
|
|
|
|
// Cleanup event listeners
|
|
EPUBJS.Render.Iframe.prototype.unload = function(){
|
|
this.window.removeEventListener("resize", this.resized);
|
|
};
|
|
|
|
//-- Enable binding events to Render
|
|
RSVP.EventTarget.mixin(EPUBJS.Render.Iframe.prototype);
|
|
EPUBJS.Renderer = function(renderMethod) {
|
|
// Dom events to listen for
|
|
this.listenedEvents = ["keydown", "keyup", "keypressed", "mouseup", "mousedown", "click"];
|
|
|
|
/**
|
|
* Setup a render method.
|
|
* Options are: Iframe
|
|
*/
|
|
if(renderMethod && typeof(EPUBJS.Render[renderMethod]) != "undefined"){
|
|
this.render = new EPUBJS.Render[renderMethod]();
|
|
} else {
|
|
console.error("Not a Valid Rendering Method");
|
|
}
|
|
|
|
// Listen for load events
|
|
this.render.on("render:loaded", this.loaded.bind(this));
|
|
|
|
// Cached for replacement urls from storage
|
|
this.caches = {};
|
|
|
|
// Blank Cfi for Parsing
|
|
this.epubcfi = new EPUBJS.EpubCFI();
|
|
|
|
this.spreads = true;
|
|
this.isForcedSingle = false;
|
|
this.resized = _.throttle(this.onResized.bind(this), 10);
|
|
|
|
this.layoutSettings = {};
|
|
|
|
//-- Adds Hook methods to the Book prototype
|
|
// Hooks will all return before triggering the callback.
|
|
EPUBJS.Hooks.mixin(this);
|
|
//-- Get pre-registered hooks for events
|
|
this.getHooks("beforeChapterDisplay");
|
|
};
|
|
|
|
//-- Renderer events for listening
|
|
EPUBJS.Renderer.prototype.Events = [
|
|
"renderer:keydown",
|
|
"renderer:keyup",
|
|
"renderer:keypressed",
|
|
"renderer:mouseup",
|
|
"renderer:mousedown",
|
|
"renderer:click",
|
|
"renderer:selected",
|
|
"renderer:chapterUnloaded",
|
|
"renderer:chapterDisplayed",
|
|
"renderer:locationChanged",
|
|
"renderer:resized",
|
|
"renderer:spreads"
|
|
];
|
|
|
|
/**
|
|
* Creates an element to render to.
|
|
* Resizes to passed width and height or to the elements size
|
|
*/
|
|
EPUBJS.Renderer.prototype.initialize = function(element, width, height){
|
|
this.container = element;
|
|
this.element = this.render.create();
|
|
|
|
this.initWidth = width;
|
|
this.initHeight = height;
|
|
|
|
this.width = width || this.container.clientWidth;
|
|
this.height = height || this.container.clientHeight;
|
|
|
|
this.container.appendChild(this.element);
|
|
|
|
if(width && height){
|
|
this.render.resize(this.width, this.height);
|
|
} else {
|
|
this.render.resize('100%', '100%');
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Display a chapter
|
|
* Takes: chapter object, global layout settings
|
|
* Returns: Promise with passed Renderer after pages has loaded
|
|
*/
|
|
EPUBJS.Renderer.prototype.displayChapter = function(chapter, globalLayout){
|
|
var renderer = this,
|
|
store = false;
|
|
|
|
// Unload the previous chapter listener
|
|
if(this.currentChapter) {
|
|
this.currentChapter.unload(); // Remove stored blobs
|
|
this.render.window.removeEventListener("resize", this.resized);
|
|
this.removeEventListeners();
|
|
this.removeSelectionListeners();
|
|
this.trigger("renderer:chapterUnloaded");
|
|
}
|
|
|
|
this.currentChapter = chapter;
|
|
this.chapterPos = 1;
|
|
|
|
this.currentChapterCfiBase = chapter.cfiBase;
|
|
|
|
this.layoutSettings = this.reconcileLayoutSettings(globalLayout, chapter.properties);
|
|
|
|
// Get the url string from the chapter (may be from storage)
|
|
return chapter.url().
|
|
then(function(url) {
|
|
return renderer.load(url);
|
|
});
|
|
|
|
};
|
|
|
|
/**
|
|
* Loads a url (string) and renders it,
|
|
* attaching event listeners and triggering hooks.
|
|
* Returns: Promise with the rendered contents.
|
|
*/
|
|
|
|
EPUBJS.Renderer.prototype.load = function(url){
|
|
var deferred = new RSVP.defer();
|
|
var loaded;
|
|
|
|
// Switch to the required layout method for the settings
|
|
this.layoutMethod = this.determineLayout(this.layoutSettings);
|
|
this.layout = new EPUBJS.Layout[this.layoutMethod]();
|
|
|
|
this.visible(false);
|
|
|
|
render = this.render.load(url);
|
|
|
|
render.then(function(contents) {
|
|
var formated;
|
|
|
|
this.contents = contents;
|
|
this.doc = this.render.document;
|
|
|
|
// Format the contents using the current layout method
|
|
formated = this.layout.format(contents, this.render.width, this.render.height);
|
|
this.render.setPageDimensions(formated.pageWidth, formated.pageHeight);
|
|
|
|
if(!this.initWidth && !this.initHeight){
|
|
this.render.window.addEventListener("resize", this.resized, false);
|
|
}
|
|
|
|
|
|
this.addEventListeners();
|
|
this.addSelectionListeners();
|
|
|
|
//-- Trigger registered hooks before displaying
|
|
this.beforeDisplay(function(){
|
|
var pages = this.layout.calculatePages();
|
|
var msg = this.currentChapter;
|
|
|
|
this.updatePages(pages);
|
|
|
|
msg.cfi = this.currentLocationCfi = this.getPageCfi();
|
|
|
|
this.trigger("renderer:chapterDisplayed", msg);
|
|
this.trigger("renderer:locationChanged", this.currentLocationCfi);
|
|
|
|
this.visible(true);
|
|
|
|
deferred.resolve(this); //-- why does this return the renderer?
|
|
}.bind(this));
|
|
|
|
}.bind(this));
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.loaded = function(url){
|
|
this.trigger("render:loaded", url);
|
|
// var uri = EPUBJS.core.uri(url);
|
|
// var relative = uri.path.replace(book.bookUrl, '');
|
|
// console.log(url, uri, relative);
|
|
};
|
|
|
|
/**
|
|
* Reconciles the current chapters layout properies with
|
|
* the global layout properities.
|
|
* Takes: global layout settings object, chapter properties string
|
|
* Returns: Object with layout properties
|
|
*/
|
|
EPUBJS.Renderer.prototype.reconcileLayoutSettings = function(global, chapter){
|
|
var settings = {};
|
|
|
|
//-- Get the global defaults
|
|
for (var attr in global) {
|
|
if (global.hasOwnProperty(attr)){
|
|
settings[attr] = global[attr];
|
|
}
|
|
}
|
|
//-- Get the chapter's display type
|
|
chapter.forEach(function(prop){
|
|
var rendition = prop.replace("rendition:", '');
|
|
var split = rendition.indexOf("-");
|
|
var property, value;
|
|
|
|
if(split != -1){
|
|
property = rendition.slice(0, split);
|
|
value = rendition.slice(split+1);
|
|
|
|
settings[property] = value;
|
|
}
|
|
});
|
|
return settings;
|
|
};
|
|
|
|
/**
|
|
* Uses the settings to determine which Layout Method is needed
|
|
* Triggers events based on the method choosen
|
|
* Takes: Layout settings object
|
|
* Returns: String of appropriate for EPUBJS.Layout function
|
|
*/
|
|
EPUBJS.Renderer.prototype.determineLayout = function(settings){
|
|
// Default is layout: reflowable & spread: auto
|
|
var spreads = this.determineSpreads(this.minSpreadWidth);
|
|
var layoutMethod = spreads ? "ReflowableSpreads" : "Reflowable";
|
|
var scroll = false;
|
|
|
|
if(settings.layout === "pre-paginated") {
|
|
layoutMethod = "Fixed";
|
|
scroll = true;
|
|
spreads = false;
|
|
}
|
|
|
|
if(settings.layout === "reflowable" && settings.spread === "none") {
|
|
layoutMethod = "Reflowable";
|
|
scroll = false;
|
|
spreads = false;
|
|
}
|
|
|
|
if(settings.layout === "reflowable" && settings.spread === "both") {
|
|
layoutMethod = "ReflowableSpreads";
|
|
scroll = false;
|
|
spreads = true;
|
|
}
|
|
|
|
this.spreads = spreads;
|
|
this.render.scroll(scroll);
|
|
this.trigger("renderer:spreads", spreads);
|
|
return layoutMethod;
|
|
};
|
|
|
|
// Shortcut to trigger the hook before displaying the chapter
|
|
EPUBJS.Renderer.prototype.beforeDisplay = function(callback, renderer){
|
|
this.triggerHooks("beforeChapterDisplay", callback, this);
|
|
};
|
|
|
|
// Update the renderer with the information passed by the layout
|
|
EPUBJS.Renderer.prototype.updatePages = function(layout){
|
|
this.displayedPages = layout.displayedPages;
|
|
this.currentChapter.pages = layout.pageCount;
|
|
};
|
|
|
|
// Apply the layout again and jump back to the previous cfi position
|
|
EPUBJS.Renderer.prototype.reformat = function(){
|
|
var renderer = this;
|
|
var formated, pages;
|
|
if(!this.contents) return;
|
|
|
|
formated = this.layout.format(this.contents, this.render.width, this.render.height);
|
|
this.render.setPageDimensions(formated.pageWidth, formated.pageHeight);
|
|
|
|
pages = renderer.layout.calculatePages();
|
|
renderer.updatePages(pages);
|
|
|
|
// Give the css styles time to update
|
|
clearTimeout(this.timeoutTillCfi);
|
|
this.timeoutTillCfi = setTimeout(function(){
|
|
//-- Go to current page after formating
|
|
if(renderer.currentLocationCfi){
|
|
renderer.gotoCfi(renderer.currentLocationCfi);
|
|
}
|
|
this.timeoutTillCfi = null;
|
|
}, 10);
|
|
|
|
};
|
|
|
|
// Hide and show the render's container .
|
|
EPUBJS.Renderer.prototype.visible = function(bool){
|
|
if(typeof(bool) === "undefined") {
|
|
return this.container.style.visibility;
|
|
}
|
|
|
|
if(bool === true){
|
|
this.container.style.visibility = "visible";
|
|
}else if(bool === false){
|
|
this.container.style.visibility = "hidden";
|
|
}
|
|
};
|
|
|
|
// Remove the render element and clean up listeners
|
|
EPUBJS.Renderer.prototype.remove = function() {
|
|
if(this.render.window) {
|
|
this.render.unload();
|
|
this.render.window.removeEventListener("resize", this.resized);
|
|
this.removeEventListeners();
|
|
this.removeSelectionListeners();
|
|
}
|
|
|
|
this.container.removeChild(this.element);
|
|
};
|
|
|
|
//-- STYLES
|
|
|
|
EPUBJS.Renderer.prototype.applyStyles = function(styles) {
|
|
for (var style in styles) {
|
|
this.render.setStyle(style, styles[style]);
|
|
}
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.setStyle = function(style, val, prefixed){
|
|
this.render.setStyle(style, val, prefixed);
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.removeStyle = function(style){
|
|
this.render.removeStyle(style);
|
|
};
|
|
|
|
//-- HEAD TAGS
|
|
EPUBJS.Renderer.prototype.applyHeadTags = function(headTags) {
|
|
for ( var headTag in headTags ) {
|
|
this.render.addHeadTag(headTag, headTags[headTag]);
|
|
}
|
|
};
|
|
|
|
//-- NAVIGATION
|
|
|
|
EPUBJS.Renderer.prototype.page = function(pg){
|
|
if(pg >= 1 && pg <= this.displayedPages){
|
|
this.chapterPos = pg;
|
|
|
|
this.render.page(pg);
|
|
|
|
this.currentLocationCfi = this.getPageCfi();
|
|
this.trigger("renderer:locationChanged", this.currentLocationCfi);
|
|
return true;
|
|
}
|
|
//-- Return false if page is greater than the total
|
|
return false;
|
|
};
|
|
|
|
// Short cut to find next page's cfi starting at the last visible element
|
|
EPUBJS.Renderer.prototype.nextPage = function(){
|
|
var pg = this.chapterPos + 1;
|
|
if(pg <= this.displayedPages){
|
|
this.chapterPos = pg;
|
|
|
|
this.render.page(pg);
|
|
|
|
this.currentLocationCfi = this.getPageCfi(this.visibileEl);
|
|
this.trigger("renderer:locationChanged", this.currentLocationCfi);
|
|
|
|
return true;
|
|
}
|
|
//-- Return false if page is greater than the total
|
|
return false;
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.prevPage = function(){
|
|
return this.page(this.chapterPos - 1);
|
|
};
|
|
|
|
//-- Show the page containing an Element
|
|
EPUBJS.Renderer.prototype.pageByElement = function(el){
|
|
var pg;
|
|
if(!el) return;
|
|
|
|
pg = this.render.getPageNumberByElement(el);
|
|
this.page(pg);
|
|
};
|
|
|
|
// Jump to the last page of the chapter
|
|
EPUBJS.Renderer.prototype.lastPage = function(){
|
|
this.page(this.displayedPages);
|
|
};
|
|
|
|
//-- Find a section by fragement id
|
|
EPUBJS.Renderer.prototype.section = function(fragment){
|
|
var el = this.doc.getElementById(fragment),
|
|
left, pg;
|
|
|
|
if(el){
|
|
this.pageByElement(el);
|
|
}
|
|
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.firstElementisTextNode = function(node) {
|
|
var children = node.childNodes;
|
|
var leng = children.length;
|
|
|
|
if(leng &&
|
|
children[0] && // First Child
|
|
children[0].nodeType === 3 && // This is a textNodes
|
|
children[0].textContent.trim().length) { // With non whitespace or return charecters
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
// Walk the node tree from a start element to next visible element
|
|
EPUBJS.Renderer.prototype.walk = function(node) {
|
|
var r, children, leng,
|
|
startNode = node,
|
|
prevNode,
|
|
stack = [startNode];
|
|
|
|
var STOP = 10000, ITER=0;
|
|
|
|
while(!r && stack.length) {
|
|
|
|
node = stack.shift();
|
|
if( this.render.isElementVisible(node) && this.firstElementisTextNode(node)) {
|
|
r = node;
|
|
}
|
|
|
|
if(!r && node && node.childElementCount > 0){
|
|
children = node.children;
|
|
if (children && children.length) {
|
|
leng = children.length ? children.length : 0;
|
|
} else {
|
|
return r;
|
|
}
|
|
for (var i = leng-1; i >= 0; i--) {
|
|
if(children[i] != prevNode) stack.unshift(children[i]);
|
|
}
|
|
}
|
|
|
|
if(!r && stack.length === 0 && startNode && startNode.parentNode !== null){
|
|
stack.push(startNode.parentNode);
|
|
prevNode = startNode;
|
|
startNode = startNode.parentNode;
|
|
}
|
|
|
|
|
|
ITER++;
|
|
if(ITER > STOP) {
|
|
console.error("ENDLESS LOOP");
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
return r;
|
|
};
|
|
|
|
// Get the cfi of the current page
|
|
EPUBJS.Renderer.prototype.getPageCfi = function(prevEl){
|
|
this.visibileEl = this.findFirstVisible(prevEl);
|
|
|
|
return this.epubcfi.generateCfiFromElement(this.visibileEl, this.currentChapter.cfiBase);
|
|
};
|
|
|
|
// Goto a cfi position in the current chapter
|
|
EPUBJS.Renderer.prototype.gotoCfi = function(cfi){
|
|
var element;
|
|
var pg;
|
|
|
|
if(_.isString(cfi)){
|
|
cfi = this.epubcfi.parse(cfi);
|
|
}
|
|
|
|
marker = this.epubcfi.addMarker(cfi, this.doc);
|
|
if(marker) {
|
|
pg = this.render.getPageNumberByElement(marker);
|
|
// Must Clean up Marker before going to page
|
|
this.epubcfi.removeMarker(marker, this.doc);
|
|
this.page(pg);
|
|
}
|
|
};
|
|
|
|
// Walk nodes until a visible element is found
|
|
EPUBJS.Renderer.prototype.findFirstVisible = function(startEl){
|
|
var el = startEl || this.render.getBaseElement();
|
|
var found;
|
|
found = this.walk(el);
|
|
|
|
if(found) {
|
|
return found;
|
|
}else{
|
|
return startEl;
|
|
}
|
|
|
|
};
|
|
|
|
/*
|
|
EPUBJS.Renderer.prototype.route = function(hash, callback){
|
|
var location = window.location.hash.replace('#/', '');
|
|
if(this.useHash && location.length && location != this.prevLocation){
|
|
this.show(location, callback);
|
|
this.prevLocation = location;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
EPUBJS.Renderer.prototype.hideHashChanges = function(){
|
|
this.useHash = false;
|
|
}
|
|
|
|
*/
|
|
|
|
//-- Listeners for events in the frame
|
|
|
|
EPUBJS.Renderer.prototype.onResized = function(e){
|
|
var spreads;
|
|
|
|
this.width = this.container.clientWidth;
|
|
this.height = this.container.clientHeight;
|
|
|
|
spreads = this.determineSpreads(this.minSpreadWidth);
|
|
// Only re-layout if the spreads have switched
|
|
if(spreads != this.spreads){
|
|
this.spreads = spreads;
|
|
this.layoutMethod = this.determineLayout(this.layoutSettings);
|
|
this.layout = new EPUBJS.Layout[this.layoutMethod]();
|
|
}
|
|
|
|
if(this.contents){
|
|
this.reformat();
|
|
}
|
|
|
|
this.trigger("renderer:resized", {
|
|
width: this.width,
|
|
height: this.height
|
|
});
|
|
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.addEventListeners = function(){
|
|
|
|
this.listenedEvents.forEach(function(eventName){
|
|
this.render.document.addEventListener(eventName, this.triggerEvent.bind(this), false);
|
|
}, this);
|
|
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.removeEventListeners = function(){
|
|
|
|
this.listenedEvents.forEach(function(eventName){
|
|
this.render.document.removeEventListener(eventName, this.triggerEvent, false);
|
|
}, this);
|
|
|
|
};
|
|
|
|
// Pass browser events
|
|
EPUBJS.Renderer.prototype.triggerEvent = function(e){
|
|
this.trigger("renderer:"+e.type, e);
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.addSelectionListeners = function(){
|
|
this.render.document.addEventListener("selectionchange", this.onSelectionChange.bind(this), false);
|
|
this.render.window.addEventListener("mouseup", this.onMouseUp.bind(this), false);
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.removeSelectionListeners = function(){
|
|
this.doc.removeEventListener("selectionchange", this.onSelectionChange, false);
|
|
this.render.window.removeEventListener("mouseup", this.onMouseUp, false);
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.onSelectionChange = function(e){
|
|
this.highlighted = true;
|
|
};
|
|
|
|
// only pass selection on mouse up
|
|
EPUBJS.Renderer.prototype.onMouseUp = function(e){
|
|
var selection;
|
|
if(this.highlighted) {
|
|
selection = this.render.window.getSelection();
|
|
this.trigger("renderer:selected", selection);
|
|
this.highlighted = false;
|
|
}
|
|
};
|
|
|
|
|
|
//-- Spreads
|
|
|
|
EPUBJS.Renderer.prototype.setMinSpreadWidth = function(width){
|
|
this.minSpreadWidth = width;
|
|
this.spreads = this.determineSpreads(width);
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.determineSpreads = function(cutoff){
|
|
if(this.isForcedSingle || !cutoff || this.width < cutoff) {
|
|
return false; //-- Single Page
|
|
}else{
|
|
return true; //-- Double Page
|
|
}
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.forceSingle = function(bool){
|
|
if(bool) {
|
|
this.isForcedSingle = true;
|
|
this.spreads = false;
|
|
} else {
|
|
this.isForcedSingle = false;
|
|
this.spreads = this.determineSpreads(width);
|
|
}
|
|
};
|
|
|
|
//-- Content Replacements
|
|
|
|
EPUBJS.Renderer.prototype.replace = function(query, func, finished, progress){
|
|
var items = this.contents.querySelectorAll(query),
|
|
resources = Array.prototype.slice.call(items),
|
|
count = resources.length,
|
|
after = function(result, full){
|
|
count--;
|
|
if(progress) progress(result, full, count);
|
|
if(count <= 0 && finished) finished(true);
|
|
};
|
|
|
|
if(count === 0) {
|
|
finished(false);
|
|
return;
|
|
}
|
|
resources.forEach(function(item){
|
|
|
|
func(item, after);
|
|
|
|
}.bind(this));
|
|
|
|
};
|
|
|
|
EPUBJS.Renderer.prototype.replaceWithStored = function(query, attr, func, callback) {
|
|
var _oldUrls,
|
|
_newUrls = {},
|
|
_store = this.currentChapter.store,
|
|
_cache = this.caches[query],
|
|
_uri = EPUBJS.core.uri(this.currentChapter.absolute),
|
|
_chapterBase = _uri.base,
|
|
_attr = attr,
|
|
_wait = 2000,
|
|
progress = function(url, full, count) {
|
|
_newUrls[full] = url;
|
|
},
|
|
finished = function(notempty) {
|
|
if(callback) callback();
|
|
|
|
_.each(_oldUrls, function(url){
|
|
_store.revokeUrl(url);
|
|
});
|
|
|
|
_cache = _newUrls;
|
|
};
|
|
|
|
if(!_store) return;
|
|
|
|
if(!_cache) _cache = {};
|
|
_oldUrls = _.clone(_cache);
|
|
|
|
this.replace(query, function(link, done){
|
|
var src = link.getAttribute(_attr),
|
|
full = EPUBJS.core.resolveUrl(_chapterBase, src);
|
|
|
|
var replaceUrl = function(url) {
|
|
var timeout;
|
|
|
|
link.onload = function(){
|
|
clearTimeout(timeout);
|
|
done(url, full);
|
|
};
|
|
|
|
link.onerror = function(e){
|
|
clearTimeout(timeout);
|
|
done(url, full);
|
|
console.error(e);
|
|
};
|
|
|
|
if(query == "image") {
|
|
//-- SVG needs this to trigger a load event
|
|
link.setAttribute("externalResourcesRequired", "true");
|
|
}
|
|
|
|
if(query == "link[href]") {
|
|
//-- Only Stylesheet links seem to have a load events, just continue others
|
|
done(url, full);
|
|
}
|
|
|
|
link.setAttribute(_attr, url);
|
|
|
|
//-- If elements never fire Load Event, should continue anyways
|
|
timeout = setTimeout(function(){
|
|
done(url, full);
|
|
}, _wait);
|
|
|
|
};
|
|
|
|
if(full in _oldUrls){
|
|
replaceUrl(_oldUrls[full]);
|
|
_newUrls[full] = _oldUrls[full];
|
|
delete _oldUrls[full];
|
|
}else{
|
|
func(_store, full, replaceUrl, link);
|
|
}
|
|
|
|
}, finished, progress);
|
|
};
|
|
|
|
//-- Enable binding events to Renderer
|
|
RSVP.EventTarget.mixin(EPUBJS.Renderer.prototype);
|
|
var EPUBJS = EPUBJS || {};
|
|
EPUBJS.replace = {};
|
|
|
|
//-- Replaces the relative links within the book to use our internal page changer
|
|
EPUBJS.replace.hrefs = function(callback, renderer){
|
|
var book = this;
|
|
var replacments = function(link, done){
|
|
var href = link.getAttribute("href"),
|
|
relative = href.search("://"),
|
|
fragment = href[0] == "#";
|
|
|
|
if(relative != -1){
|
|
|
|
link.setAttribute("target", "_blank");
|
|
|
|
}else{
|
|
|
|
link.onclick = function(){
|
|
book.goto(href);
|
|
return false;
|
|
};
|
|
|
|
}
|
|
done();
|
|
|
|
};
|
|
|
|
renderer.replace("a[href]", replacments, callback);
|
|
|
|
};
|
|
|
|
EPUBJS.replace.head = function(callback, renderer) {
|
|
|
|
renderer.replaceWithStored("link[href]", "href", EPUBJS.replace.links, callback);
|
|
|
|
};
|
|
|
|
|
|
//-- Replaces assets src's to point to stored version if browser is offline
|
|
EPUBJS.replace.resources = function(callback, renderer){
|
|
//srcs = this.doc.querySelectorAll('[src]');
|
|
renderer.replaceWithStored("[src]", "src", EPUBJS.replace.srcs, callback);
|
|
|
|
};
|
|
|
|
EPUBJS.replace.svg = function(callback, renderer) {
|
|
|
|
renderer.replaceWithStored("image", "xlink:href", function(_store, full, done){
|
|
_store.getUrl(full).then(done);
|
|
}, callback);
|
|
|
|
};
|
|
|
|
EPUBJS.replace.srcs = function(_store, full, done){
|
|
|
|
_store.getUrl(full).then(done);
|
|
|
|
};
|
|
|
|
//-- Replaces links in head, such as stylesheets - link[href]
|
|
EPUBJS.replace.links = function(_store, full, done, link){
|
|
|
|
//-- Handle replacing urls in CSS
|
|
if(link.getAttribute("rel") === "stylesheet") {
|
|
EPUBJS.replace.stylesheets(_store, full).then(function(url, full){
|
|
// done
|
|
setTimeout(function(){
|
|
done(url, full);
|
|
}, 5); //-- Allow for css to apply before displaying chapter
|
|
});
|
|
}else{
|
|
_store.getUrl(full).then(done);
|
|
}
|
|
};
|
|
|
|
EPUBJS.replace.stylesheets = function(_store, full) {
|
|
var deferred = new RSVP.defer();
|
|
|
|
if(!_store) return;
|
|
|
|
_store.getText(full).then(function(text){
|
|
var url;
|
|
|
|
EPUBJS.replace.cssUrls(_store, full, text).then(function(newText){
|
|
var _URL = window.URL || window.webkitURL || window.mozURL;
|
|
|
|
var blob = new Blob([newText], { "type" : "text\/css" }),
|
|
url = _URL.createObjectURL(blob);
|
|
|
|
deferred.resolve(url);
|
|
|
|
}, function(e) {
|
|
console.error(e);
|
|
});
|
|
|
|
});
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
EPUBJS.replace.cssUrls = function(_store, base, text){
|
|
var deferred = new RSVP.defer(),
|
|
promises = [],
|
|
matches = text.match(/url\(\'?\"?([^\'|^\"^\)]*)\'?\"?\)/g);
|
|
|
|
if(!_store) return;
|
|
|
|
if(!matches){
|
|
deferred.resolve(text);
|
|
return deferred.promise;
|
|
}
|
|
|
|
matches.forEach(function(str){
|
|
var full = EPUBJS.core.resolveUrl(base, str.replace(/url\(|[|\)|\'|\"]/g, ''));
|
|
var replaced = _store.getUrl(full).then(function(url){
|
|
text = text.replace(str, 'url("'+url+'")');
|
|
});
|
|
|
|
promises.push(replaced);
|
|
});
|
|
|
|
RSVP.all(promises).then(function(){
|
|
deferred.resolve(text);
|
|
});
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
EPUBJS.Unarchiver = function(url){
|
|
|
|
this.libPath = EPUBJS.filePath;
|
|
this.zipUrl = url;
|
|
this.loadLib();
|
|
this.urlCache = {};
|
|
|
|
this.zipFs = new zip.fs.FS();
|
|
|
|
return this.promise;
|
|
|
|
};
|
|
|
|
//-- Load the zip lib and set the workerScriptsPath
|
|
EPUBJS.Unarchiver.prototype.loadLib = function(callback){
|
|
if(typeof(zip) == "undefined") console.error("Zip lib not loaded");
|
|
|
|
/*
|
|
//-- load script
|
|
EPUBJS.core.loadScript(this.libPath+"zip.js", function(){
|
|
//-- Tell zip where it is located
|
|
zip.workerScriptsPath = this.libPath;
|
|
callback();
|
|
}.bind(this));
|
|
*/
|
|
// console.log(this.libPath)
|
|
zip.workerScriptsPath = this.libPath;
|
|
};
|
|
|
|
EPUBJS.Unarchiver.prototype.openZip = function(zipUrl, callback){
|
|
var deferred = new RSVP.defer();
|
|
var zipFs = this.zipFs;
|
|
zipFs.importHttpContent(zipUrl, false, function() {
|
|
deferred.resolve(zipFs);
|
|
}, this.failed);
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
EPUBJS.Unarchiver.prototype.getXml = function(url, encoding){
|
|
|
|
return this.getText(url, encoding).
|
|
then(function(text){
|
|
var parser = new DOMParser();
|
|
return parser.parseFromString(text, "application/xml");
|
|
});
|
|
|
|
};
|
|
|
|
EPUBJS.Unarchiver.prototype.getUrl = function(url, mime){
|
|
var unarchiver = this;
|
|
var deferred = new RSVP.defer();
|
|
var decodededUrl = window.decodeURIComponent(url);
|
|
var entry = this.zipFs.find(decodededUrl);
|
|
var _URL = window.URL || window.webkitURL || window.mozURL;
|
|
|
|
if(!entry) {
|
|
deferred.reject({
|
|
message : "File not found in the epub: " + url,
|
|
stack : new Error().stack
|
|
});
|
|
return deferred.promise;
|
|
}
|
|
|
|
if(url in this.urlCache) {
|
|
deferred.resolve(this.urlCache[url]);
|
|
return deferred.promise;
|
|
}
|
|
|
|
entry.getBlob(mime || zip.getMimeType(entry.name), function(blob){
|
|
var tempUrl = _URL.createObjectURL(blob);
|
|
deferred.resolve(tempUrl);
|
|
unarchiver.urlCache[url] = tempUrl;
|
|
});
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
EPUBJS.Unarchiver.prototype.getText = function(url, encoding){
|
|
var unarchiver = this;
|
|
var deferred = new RSVP.defer();
|
|
var decodededUrl = window.decodeURIComponent(url);
|
|
var entry = this.zipFs.find(decodededUrl);
|
|
var _URL = window.URL || window.webkitURL || window.mozURL;
|
|
|
|
if(!entry) {
|
|
console.warn("File not found in the contained epub:", url);
|
|
return deferred.promise;
|
|
}
|
|
|
|
entry.getText(function(text){
|
|
deferred.resolve(text);
|
|
}, null, null, encoding || 'UTF-8');
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
EPUBJS.Unarchiver.prototype.revokeUrl = function(url){
|
|
var _URL = window.URL || window.webkitURL || window.mozURL;
|
|
var fromCache = unarchiver.urlCache[url];
|
|
if(fromCache) _URL.revokeObjectURL(fromCache);
|
|
};
|
|
|
|
EPUBJS.Unarchiver.prototype.failed = function(error){
|
|
console.error(error);
|
|
};
|
|
|
|
EPUBJS.Unarchiver.prototype.afterSaved = function(error){
|
|
this.callback();
|
|
};
|
|
|
|
EPUBJS.Unarchiver.prototype.toStorage = function(entries){
|
|
var timeout = 0,
|
|
delay = 20,
|
|
that = this,
|
|
count = entries.length;
|
|
|
|
function callback(){
|
|
count--;
|
|
if(count === 0) that.afterSaved();
|
|
}
|
|
|
|
entries.forEach(function(entry){
|
|
|
|
setTimeout(function(entry){
|
|
that.saveEntryFileToStorage(entry, callback);
|
|
}, timeout, entry);
|
|
|
|
timeout += delay;
|
|
});
|
|
|
|
console.log("time", timeout);
|
|
|
|
//entries.forEach(this.saveEntryFileToStorage.bind(this));
|
|
};
|
|
|
|
EPUBJS.Unarchiver.prototype.saveEntryFileToStorage = function(entry, callback){
|
|
var that = this;
|
|
entry.getData(new zip.BlobWriter(), function(blob) {
|
|
EPUBJS.storage.save(entry.filename, blob, callback);
|
|
});
|
|
};
|
|
|
|
//# sourceMappingURL=epub_no_underscore.js.map
|