1515 lines
48 KiB
JavaScript
1515 lines
48 KiB
JavaScript
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.jiboLoader = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const AssetToken_1 = require("./AssetToken");
|
|
const log_1 = require("./log");
|
|
const log = log_1.default.createChild('AssetCache');
|
|
class CacheItem {
|
|
constructor(key) {
|
|
this.key = key;
|
|
this.pendingCallbacks = new Map();
|
|
this.tokens = new Set();
|
|
this.contentIsError = false;
|
|
this.content = null;
|
|
this.subAssets = null;
|
|
}
|
|
get isPending() {
|
|
return !this.content;
|
|
}
|
|
addPending(token, callback) {
|
|
this.pendingCallbacks.set(token, callback);
|
|
}
|
|
removePending(token) {
|
|
if (!this.pendingCallbacks) {
|
|
return;
|
|
}
|
|
if (this.pendingCallbacks.has(token)) {
|
|
this.pendingCallbacks.delete(token);
|
|
}
|
|
if (this.tokens.has(token)) {
|
|
this.tokens.delete(token);
|
|
}
|
|
}
|
|
completeLoad(err, content, subAssets) {
|
|
this.content = content;
|
|
this.subAssets = subAssets || null;
|
|
this.contentIsError = !!err;
|
|
const callbacks = Array.from(this.pendingCallbacks.values());
|
|
this.pendingCallbacks.clear();
|
|
for (let callback of callbacks) {
|
|
callback(err, content);
|
|
}
|
|
}
|
|
destroy(cache) {
|
|
if (this.content && this.content.destroy) {
|
|
this.content.destroy(true);
|
|
}
|
|
if (this.content && this.content.tagName === 'IMG') {
|
|
this.content.src = '';
|
|
}
|
|
this.content = null;
|
|
this.key = null;
|
|
if (this.subAssets) {
|
|
for (let i = 0; i < this.subAssets.length; ++i) {
|
|
cache.delete(this.subAssets[i]);
|
|
}
|
|
this.subAssets = null;
|
|
}
|
|
this.pendingCallbacks = null;
|
|
}
|
|
}
|
|
exports.CacheItem = CacheItem;
|
|
class NamedCache {
|
|
constructor(name) {
|
|
this.name = name;
|
|
this.idMap = new Map();
|
|
this.tokens = new Set();
|
|
}
|
|
load(token) {
|
|
const { id, key } = token;
|
|
if (this.idMap.has(id) && this.idMap.get(id) !== key) {
|
|
log.info(`In cache ${this.name} overwriting asset ${id} with key of ${this.idMap.get(id)} with new key of ${key}`);
|
|
}
|
|
this.idMap.set(id, key);
|
|
this.tokens.add(token);
|
|
}
|
|
unload(token) {
|
|
this.tokens.delete(token);
|
|
const { id } = token;
|
|
const otherTokens = this.tokens.values();
|
|
let otherId = false;
|
|
for (let item of otherTokens) {
|
|
if (item.id === id) {
|
|
otherId = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!otherId) {
|
|
this.idMap.delete(id);
|
|
}
|
|
}
|
|
}
|
|
class AssetCache {
|
|
constructor(manager) {
|
|
this._manager = manager;
|
|
this._cache = new Map();
|
|
this._cachesMap = new Map();
|
|
}
|
|
addCache(id) {
|
|
if (this._cachesMap.has(id)) {
|
|
return;
|
|
}
|
|
this._cachesMap.set(id, new NamedCache(id));
|
|
}
|
|
read(id, cacheId) {
|
|
if (!cacheId) {
|
|
const item = this._cache.get(id);
|
|
return item ? item.content : null;
|
|
}
|
|
const cache = this._cachesMap.get(cacheId);
|
|
if (!cache) {
|
|
throw new Error(`AssetCache.read(): unable to find cache: '${cacheId}'`);
|
|
}
|
|
const item = this._cache.get(cache.idMap.get(id));
|
|
return item ? item.content : null;
|
|
}
|
|
isLoaded(id, cacheId) {
|
|
if (!cacheId) {
|
|
const item = this._cache.get(id);
|
|
return item ? !item.isPending : false;
|
|
}
|
|
const cache = this._cachesMap.get(cacheId);
|
|
if (!cache) {
|
|
throw new Error(`AssetCache.isLoaded(): unable to find cache: '${cacheId}'`);
|
|
}
|
|
const item = this._cache.get(cache.idMap.get(id));
|
|
return item ? !item.isPending : false;
|
|
}
|
|
wasError(id, cacheId) {
|
|
if (!cacheId) {
|
|
const item = this._cache.get(id);
|
|
return item ? item.contentIsError : false;
|
|
}
|
|
const cache = this._cachesMap.get(cacheId);
|
|
if (!cache) {
|
|
throw new Error(`AssetCache.wasError(): unable to find cache: '${cacheId}'`);
|
|
}
|
|
const item = this._cache.get(cache.idMap.get(id));
|
|
return item ? item.contentIsError : false;
|
|
}
|
|
prepare(key, cacheName, id) {
|
|
const cache = this._cachesMap.get(cacheName);
|
|
if (!cache) {
|
|
throw new Error(`AssetCache.prepare(): unable to find cache: '${cacheName}'`);
|
|
}
|
|
const token = new AssetToken_1.default(this, key, cacheName, id);
|
|
cache.load(token);
|
|
let cacheItem = this._cache.get(key);
|
|
if (!cacheItem) {
|
|
cacheItem = new CacheItem(key);
|
|
this._cache.set(key, cacheItem);
|
|
}
|
|
cacheItem.tokens.add(token);
|
|
return token;
|
|
}
|
|
addPending(token, callback) {
|
|
let cacheItem = this._cache.get(token.key);
|
|
if (!cacheItem) {
|
|
throw new Error(`AssetCache.addPending(): unable to find item: '${token.key}'`);
|
|
}
|
|
let isFirst = cacheItem.pendingCallbacks.size === 0;
|
|
cacheItem.addPending(token, callback);
|
|
return isFirst;
|
|
}
|
|
cancelPending(token) {
|
|
let cacheItem = this._cache.get(token.key);
|
|
if (!cacheItem) {
|
|
return;
|
|
}
|
|
cacheItem.removePending(token);
|
|
if (cacheItem.tokens.size === 0) {
|
|
this._cache.delete(token.key);
|
|
}
|
|
}
|
|
completePending(err, result) {
|
|
const { token } = result;
|
|
if (!token.isValid) {
|
|
return;
|
|
}
|
|
const cache = this._cachesMap.get(token.cache);
|
|
if (!cache) {
|
|
throw new Error(`AssetCache.completePending(): unable to find cache: '${token.cache}'`);
|
|
}
|
|
let cacheItem = this._cache.get(token.key);
|
|
if (cacheItem) {
|
|
cacheItem.completeLoad(err, result.result, result.subAssets);
|
|
}
|
|
else {
|
|
log.warn(`completePending() - unable to complete load for ${token.key} because no item was found`);
|
|
}
|
|
}
|
|
delete(token) {
|
|
const cacheId = token.cache;
|
|
const cache = this._cachesMap.get(cacheId);
|
|
if (cache) {
|
|
cache.unload(token);
|
|
}
|
|
this.unloadItem(token);
|
|
}
|
|
empty(cacheId) {
|
|
const cache = this._cachesMap.get(cacheId);
|
|
if (!cache) {
|
|
return;
|
|
}
|
|
for (let entry of cache.tokens.values()) {
|
|
entry.unload();
|
|
}
|
|
cache.idMap.clear();
|
|
cache.tokens.clear();
|
|
}
|
|
destroy() {
|
|
for (let id in this._cachesMap) {
|
|
this.empty(id);
|
|
}
|
|
this._cache = null;
|
|
this._cachesMap = null;
|
|
}
|
|
unloadItem(token) {
|
|
const item = this._cache.get(token.key);
|
|
if (item) {
|
|
item.tokens.delete(token);
|
|
if (item.tokens.size < 1) {
|
|
item.destroy(this);
|
|
this._cache.delete(token.key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
exports.default = AssetCache;
|
|
|
|
},{"./AssetToken":4,"./log":16}],2:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const events_1 = require("events");
|
|
const Task_1 = require("./tasks/Task");
|
|
const AssetUtils_1 = require("./AssetUtils");
|
|
const log_1 = require("./log");
|
|
const log = log_1.default.createChild('AssetLoad');
|
|
class AssetLoad extends events_1.EventEmitter {
|
|
constructor(manager) {
|
|
super();
|
|
this.manager = manager;
|
|
this.id = AssetLoad.ID++;
|
|
this.mode = MAP_MODE;
|
|
this.maxLoads = 0;
|
|
this.cacheAll = null;
|
|
this.remoteAll = false;
|
|
this.timeoutAll = 0;
|
|
this.loadedTokens = [];
|
|
this.tasks = [];
|
|
this.results = null;
|
|
this.running = false;
|
|
this.numLoaded = 0;
|
|
this.numLoading = 0;
|
|
this.total = 0;
|
|
}
|
|
get tokens() {
|
|
const output = [];
|
|
if (this.tasks) {
|
|
this.tasks.forEach((task) => {
|
|
if (task.token) {
|
|
output.push(task.token);
|
|
}
|
|
});
|
|
}
|
|
if (this.loadedTokens) {
|
|
output.push(...this.loadedTokens);
|
|
}
|
|
return output.filter(item => !!item);
|
|
}
|
|
toString() {
|
|
return "[AssetLoad (index: " + this.id + ")]";
|
|
}
|
|
setup(assets, options) {
|
|
this.maxLoads = options.maxLoads;
|
|
this.cacheAll = options.cacheAll;
|
|
this.remoteAll = options.remoteAll;
|
|
this.timeoutAll = options.timeoutAll;
|
|
this.mode = this.addTasks(assets);
|
|
this.results = this.getAssetsContainer(this.mode);
|
|
if (options.autoStart) {
|
|
this.start();
|
|
}
|
|
}
|
|
cancel() {
|
|
this.loadedTokens.forEach((token) => {
|
|
this.manager.cache.delete(token);
|
|
});
|
|
this.manager.cancel(this);
|
|
}
|
|
cancelToken(token) {
|
|
let index = this.loadedTokens.indexOf(token);
|
|
if (index !== -1) {
|
|
this.loadedTokens.splice(index, 1);
|
|
}
|
|
index = this.tasks.findIndex((item) => {
|
|
return item.token === token;
|
|
});
|
|
if (index !== -1) {
|
|
this.tasks.splice(index, 1);
|
|
}
|
|
if (this.tasks.length === 0) {
|
|
if (this.loadedTokens.length === 0) {
|
|
this.cancel();
|
|
}
|
|
else {
|
|
this.emit('complete', null, this.results);
|
|
}
|
|
}
|
|
}
|
|
start() {
|
|
this.emit('progress', 0);
|
|
this.running = true;
|
|
this.nextTask();
|
|
}
|
|
reset() {
|
|
this.removeAllListeners('complete');
|
|
this.removeAllListeners('progress');
|
|
this.removeAllListeners('taskDone');
|
|
this.tasks.forEach((task) => {
|
|
if (task.pending) {
|
|
this.manager.cache.cancelPending(task.token);
|
|
}
|
|
task.status = Task_1.default.FINISHED;
|
|
task.destroy();
|
|
});
|
|
this.total = 0;
|
|
this.numLoaded = 0;
|
|
this.numLoading = 0;
|
|
this.mode = MAP_MODE;
|
|
this.tasks.length = 0;
|
|
this.results = null;
|
|
this.maxLoads = 0;
|
|
this.cacheAll = null;
|
|
this.remoteAll = false;
|
|
this.timeoutAll = 0;
|
|
this.running = false;
|
|
this.loadedTokens.length = 0;
|
|
}
|
|
addAssets(assets) {
|
|
const output = [];
|
|
this.addTasks(assets, output);
|
|
return output;
|
|
}
|
|
addTasks(assets, tokenOut) {
|
|
let asset;
|
|
let mode = MAP_MODE;
|
|
assets = this.applyDefaults(assets);
|
|
let isSingle = !!this.getTaskByAsset(assets);
|
|
if (isSingle) {
|
|
const task = this.addTask(assets);
|
|
if (tokenOut && task.token) {
|
|
tokenOut.push(task.token);
|
|
}
|
|
return SINGLE_MODE;
|
|
}
|
|
else {
|
|
let task;
|
|
if (Array.isArray(assets)) {
|
|
for (let i = 0; i < assets.length; i++) {
|
|
asset = this.applyDefaults(assets[i]);
|
|
task = this.addTask(asset);
|
|
if (tokenOut && task.token) {
|
|
tokenOut.push(task.token);
|
|
}
|
|
if (!task.id) {
|
|
mode = LIST_MODE;
|
|
}
|
|
}
|
|
}
|
|
else if (AssetUtils_1.default.isPlain(assets)) {
|
|
for (let id in assets) {
|
|
asset = this.applyDefaults(assets[id]);
|
|
asset.id = id;
|
|
task = this.addTask(asset);
|
|
if (tokenOut && task.token) {
|
|
tokenOut.push(task.token);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
log.debug("Asset type unsupported", asset);
|
|
}
|
|
}
|
|
return mode;
|
|
}
|
|
applyDefaults(asset) {
|
|
if (isString(asset)) {
|
|
return {
|
|
src: asset
|
|
};
|
|
}
|
|
else if (isFunction(asset)) {
|
|
return {
|
|
async: asset
|
|
};
|
|
}
|
|
return asset;
|
|
}
|
|
addTask(asset) {
|
|
let TaskClass = this.getTaskByAsset(asset);
|
|
let task;
|
|
if (TaskClass) {
|
|
if (asset.cache === undefined && this.cacheAll) {
|
|
asset.cache = this.cacheAll;
|
|
}
|
|
if (asset.remote === undefined && this.remoteAll) {
|
|
asset.remote = true;
|
|
}
|
|
if (asset.timeout === undefined && this.timeoutAll) {
|
|
asset.timeout = this.timeoutAll;
|
|
}
|
|
task = new TaskClass(this.manager, asset);
|
|
this.tasks.push(task);
|
|
++this.total;
|
|
if (!task.cache && task.needsCache) {
|
|
console.error('Trying to load %o but it needs to be cached!', task.original);
|
|
}
|
|
else if (task.cache) {
|
|
task.token = this.manager.cache.prepare(task.cacheKey, task.cache, task.id);
|
|
task.token.loader = this;
|
|
}
|
|
}
|
|
else {
|
|
log.debug("Unable to find a task definition for asset", asset);
|
|
}
|
|
return task;
|
|
}
|
|
getTaskByAsset(asset) {
|
|
let TaskClass;
|
|
let taskDefs = this.manager.taskDefs;
|
|
for (let i = 0, len = taskDefs.length; i < len; i++) {
|
|
TaskClass = taskDefs[i];
|
|
if (TaskClass.test(asset)) {
|
|
return TaskClass;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
nextTask() {
|
|
let task;
|
|
for (let i = 0; i < this.tasks.length; i++) {
|
|
if (this.tasks[i].status === Task_1.default.WAITING) {
|
|
task = this.tasks[i];
|
|
break;
|
|
}
|
|
}
|
|
if (!task) {
|
|
return;
|
|
}
|
|
task.status = Task_1.default.RUNNING;
|
|
this.numLoading++;
|
|
if (task.cache && this.manager.cache.isLoaded(task.cacheKey)) {
|
|
process.nextTick(() => {
|
|
const result = this.manager.cache.read(task.cacheKey);
|
|
if (this.manager.cache.wasError(task.cacheKey)) {
|
|
this.taskDone(task, result, null);
|
|
}
|
|
else {
|
|
this.taskDone(task, null, result);
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
if (task.cache) {
|
|
task.pending = this.taskDone.bind(this, task);
|
|
const assetData = {
|
|
token: task.token
|
|
};
|
|
const needsStart = this.manager.cache.addPending(task.token, task.pending);
|
|
if (needsStart) {
|
|
task.start((err, result) => {
|
|
if (task.status !== Task_1.default.RUNNING) {
|
|
if (result && result.destroy) {
|
|
result.destroy();
|
|
}
|
|
return;
|
|
}
|
|
assetData.result = result;
|
|
assetData.subAssets = task.subAssets;
|
|
this.manager.cache.completePending(err, assetData);
|
|
});
|
|
}
|
|
assetData.token = task.token;
|
|
}
|
|
else {
|
|
task.start(this.taskDone.bind(this, task));
|
|
}
|
|
}
|
|
if (this.maxLoads === 0 || this.numLoading < this.maxLoads) {
|
|
this.nextTask();
|
|
}
|
|
}
|
|
taskDone(task, err, result = null) {
|
|
if (!this.running) {
|
|
return;
|
|
}
|
|
let index = this.tasks.indexOf(task);
|
|
if (index === -1) {
|
|
return;
|
|
}
|
|
if (task.cache) {
|
|
this.loadedTokens.push(task.token);
|
|
}
|
|
this.tasks.splice(index, 1);
|
|
let assets = [];
|
|
log.iferr(err, 'error executing task');
|
|
if (result) {
|
|
switch (this.mode) {
|
|
case SINGLE_MODE:
|
|
this.results = result;
|
|
break;
|
|
case LIST_MODE:
|
|
this.results.push(result);
|
|
break;
|
|
case MAP_MODE:
|
|
this.results[task.id] = result;
|
|
break;
|
|
}
|
|
}
|
|
if (task.complete) {
|
|
task.complete(err, result, task.original, this);
|
|
}
|
|
if (!err) {
|
|
this.emit('taskDone', result, task.original, this);
|
|
}
|
|
task.destroy();
|
|
let mode = this.addTasks(assets);
|
|
this.emit('progress', ++this.numLoaded / this.total);
|
|
--this.numLoading;
|
|
if (this.mode === MAP_MODE && mode !== this.mode) {
|
|
log.error("Load assets require IDs to return mapped results", assets);
|
|
return;
|
|
}
|
|
if (err) {
|
|
this.emit('complete', err, null);
|
|
return;
|
|
}
|
|
if (this.tasks.length) {
|
|
this.nextTask();
|
|
}
|
|
else {
|
|
this.emit('complete', err, this.results);
|
|
}
|
|
}
|
|
getAssetsContainer(mode) {
|
|
switch (mode) {
|
|
case SINGLE_MODE:
|
|
return null;
|
|
case LIST_MODE:
|
|
return [];
|
|
case MAP_MODE:
|
|
return {};
|
|
}
|
|
}
|
|
destroy() {
|
|
this.removeAllListeners();
|
|
this.reset();
|
|
this.tasks = null;
|
|
this.manager = null;
|
|
}
|
|
}
|
|
const SINGLE_MODE = 0;
|
|
const MAP_MODE = 1;
|
|
const LIST_MODE = 2;
|
|
function isString(obj) {
|
|
return typeof obj === "string";
|
|
}
|
|
function isFunction(obj) {
|
|
return typeof obj === "function";
|
|
}
|
|
exports.default = AssetLoad;
|
|
|
|
},{"./AssetUtils":5,"./log":16,"./tasks/Task":20,"events":undefined}],3:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const AssetCache_1 = require("./AssetCache");
|
|
const Task_1 = require("./tasks/Task");
|
|
const AssetLoad_1 = require("./AssetLoad");
|
|
const RemoteLoader_1 = require("./loaders/RemoteLoader");
|
|
const LocalLoader_1 = require("./loaders/LocalLoader");
|
|
const jibo_plugins_1 = require("jibo-plugins");
|
|
const log_1 = require("./log");
|
|
const log = log_1.default.createChild('AssetManager');
|
|
function getCacheKeyFromAsset(asset, manager) {
|
|
if (asset.src) {
|
|
return manager.prepare(asset.src);
|
|
}
|
|
return asset.id;
|
|
}
|
|
exports.getCacheKeyFromAsset = getCacheKeyFromAsset;
|
|
class AssetManager {
|
|
constructor() {
|
|
this.loads = [];
|
|
this.loadPool = [];
|
|
this.taskDefs = [];
|
|
this.cache = new AssetCache_1.default(this);
|
|
this.remoteLoader = new RemoteLoader_1.default();
|
|
this.localLoader = new LocalLoader_1.default();
|
|
this.maxDefaultLoads = 4;
|
|
}
|
|
register(TaskClass, priority = 0) {
|
|
TaskClass.priority = priority;
|
|
if (!(TaskClass.prototype instanceof Task_1.default)) {
|
|
log.error("Registering task - must extend Task", TaskClass);
|
|
}
|
|
else if (!TaskClass.test) {
|
|
log.error("Registering task - must have test method");
|
|
}
|
|
this.taskDefs.push(TaskClass);
|
|
this.taskDefs.sort(function (a, b) {
|
|
return b.priority - a.priority;
|
|
});
|
|
}
|
|
load(assets, options) {
|
|
options = Object.assign({
|
|
complete: null,
|
|
progress: null,
|
|
taskDone: null,
|
|
cacheAll: false,
|
|
maxLoads: this.maxDefaultLoads,
|
|
remoteAll: false,
|
|
timeoutAll: 0,
|
|
autoStart: true
|
|
}, options);
|
|
const startAll = options.startAll;
|
|
if (startAll !== undefined) {
|
|
options.maxLoads = startAll ? 0 : 1;
|
|
}
|
|
const load = this._getLoad();
|
|
this.loads.push(load);
|
|
options.complete = this._onLoaded.bind(this, options.complete, load);
|
|
load.once('complete', options.complete);
|
|
if (options.taskDone) {
|
|
load.on('taskDone', options.taskDone);
|
|
}
|
|
load.setup(assets, options);
|
|
return load;
|
|
}
|
|
simpleLoad(uri, callback, options = {}) {
|
|
let currentLoader;
|
|
if (options.remote || jibo_plugins_1.PathUtils.isURL(uri)) {
|
|
currentLoader = this.remoteLoader;
|
|
}
|
|
else {
|
|
currentLoader = this.localLoader;
|
|
}
|
|
currentLoader.load(uri, callback, options);
|
|
}
|
|
prepare(uri, remote = false) {
|
|
let currentLoader;
|
|
if (remote || jibo_plugins_1.PathUtils.isURL(uri)) {
|
|
currentLoader = this.remoteLoader;
|
|
}
|
|
else {
|
|
currentLoader = this.localLoader;
|
|
}
|
|
return currentLoader.prepare(uri);
|
|
}
|
|
cancelAll() {
|
|
for (let i = this.loads.length - 1; i >= 0; i--) {
|
|
this.loads[i].cancel();
|
|
}
|
|
}
|
|
destroy() {
|
|
this.remoteLoader = null;
|
|
this.localLoader = null;
|
|
this.cache.destroy();
|
|
this.cache = null;
|
|
this.loadPool = null;
|
|
this.loads = null;
|
|
this.taskDefs = null;
|
|
}
|
|
cancel(load) {
|
|
const i = this.loads.indexOf(load);
|
|
if (i >= 0) {
|
|
this.loads.splice(i, 1);
|
|
load.reset();
|
|
this.loadPool.push(load);
|
|
}
|
|
}
|
|
_getLoad() {
|
|
if (this.loadPool.length > 0) {
|
|
return this.loadPool.pop();
|
|
}
|
|
return new AssetLoad_1.default(this);
|
|
}
|
|
_onLoaded(complete, load, err, results) {
|
|
let index = this.loads.indexOf(load);
|
|
if (index > -1) {
|
|
this.loads.splice(index, 1);
|
|
}
|
|
if (complete) {
|
|
complete(err, results);
|
|
}
|
|
this.cancel(load);
|
|
}
|
|
}
|
|
exports.default = AssetManager;
|
|
|
|
},{"./AssetCache":1,"./AssetLoad":2,"./loaders/LocalLoader":10,"./loaders/RemoteLoader":11,"./log":16,"./tasks/Task":20,"jibo-plugins":undefined}],4:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
class AssetToken {
|
|
get isValid() {
|
|
return !!this.owner;
|
|
}
|
|
constructor(owner, key, cache, id) {
|
|
if (!owner || !owner.delete) {
|
|
throw new Error('AssetTokens must be instantiated with an owner!');
|
|
}
|
|
this.key = key;
|
|
this.cache = cache;
|
|
this.id = id;
|
|
this.owner = owner;
|
|
this.loader = null;
|
|
}
|
|
unload() {
|
|
if (this.loader) {
|
|
this.loader.cancelToken(this);
|
|
}
|
|
if (this.owner) {
|
|
this.owner.delete(this);
|
|
}
|
|
this.loader = null;
|
|
this.owner = null;
|
|
}
|
|
cancel() {
|
|
this.unload();
|
|
}
|
|
}
|
|
exports.default = AssetToken;
|
|
|
|
},{}],5:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
class AssetUtils {
|
|
static isPlain(obj) {
|
|
if (typeof obj === 'object' && obj !== null) {
|
|
const proto = Object.getPrototypeOf(obj);
|
|
return proto === Object.prototype || proto === null;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
exports.default = AssetUtils;
|
|
|
|
},{}],6:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const AssetManager_1 = require("./AssetManager");
|
|
const AssetToken_1 = require("./AssetToken");
|
|
const AssetUtils_1 = require("./AssetUtils");
|
|
const Task_1 = require("./tasks/Task");
|
|
const LoadTask_1 = require("./tasks/LoadTask");
|
|
const ListTask_1 = require("./tasks/ListTask");
|
|
const FunctionTask_1 = require("./tasks/FunctionTask");
|
|
const LoaderError_1 = require("./errors/LoaderError");
|
|
class LoaderPlugin {
|
|
constructor() {
|
|
this.AssetToken = AssetToken_1.default;
|
|
this.AssetUtils = AssetUtils_1.default;
|
|
this.Task = Task_1.default;
|
|
this.LoadTask = LoadTask_1.default;
|
|
this.ListTask = ListTask_1.default;
|
|
this.FunctionTask = FunctionTask_1.default;
|
|
this.LoaderError = LoaderError_1.default;
|
|
this.DEFAULT_CACHE = 'load-default';
|
|
this.assetManager = new AssetManager_1.default();
|
|
this._activeCache = this.DEFAULT_CACHE;
|
|
this.addCache(this.DEFAULT_CACHE);
|
|
this.register(LoadTask_1.default, 0)
|
|
.register(ListTask_1.default, 5)
|
|
.register(FunctionTask_1.default, 10);
|
|
}
|
|
init(done) {
|
|
done();
|
|
}
|
|
register(TaskDefinition, priority = 0) {
|
|
this.assetManager.register(TaskDefinition, priority);
|
|
return this;
|
|
}
|
|
load(source, complete, progress, cache, data, remote = false, timeout = 0, format) {
|
|
let options;
|
|
if (typeof source === "string") {
|
|
source = {
|
|
src: source,
|
|
progress: progress || null,
|
|
complete: complete || null,
|
|
cache: cache || null,
|
|
remote: remote,
|
|
timeout: timeout,
|
|
format: format,
|
|
data: data || null
|
|
};
|
|
}
|
|
else {
|
|
options = complete;
|
|
if (typeof complete === "function") {
|
|
options = {
|
|
complete: complete
|
|
};
|
|
}
|
|
}
|
|
return this.assetManager.load(source, options);
|
|
}
|
|
set basePath(basePath) {
|
|
this.assetManager.localLoader.basePath = basePath;
|
|
}
|
|
get basePath() {
|
|
return this.assetManager.localLoader.basePath;
|
|
}
|
|
set baseUrl(baseUrl) {
|
|
this.assetManager.remoteLoader.baseUrl = baseUrl;
|
|
}
|
|
get baseUrl() {
|
|
return this.assetManager.remoteLoader.baseUrl;
|
|
}
|
|
unload(assets) {
|
|
if (!assets) {
|
|
return this;
|
|
}
|
|
if (Array.isArray(assets)) {
|
|
for (let i = 0; i < assets.length; i++) {
|
|
assets[i].unload();
|
|
}
|
|
return this;
|
|
}
|
|
assets.unload();
|
|
return this;
|
|
}
|
|
unloadAll(cacheId) {
|
|
this.assetManager.cache.empty(cacheId || this.activeCache);
|
|
return this;
|
|
}
|
|
cancelAll() {
|
|
this.assetManager.cancelAll();
|
|
return this;
|
|
}
|
|
addCache(cacheId) {
|
|
this.assetManager.cache.addCache(cacheId);
|
|
return this;
|
|
}
|
|
set activeCache(cacheId) {
|
|
this._activeCache = cacheId;
|
|
}
|
|
get activeCache() {
|
|
return this._activeCache;
|
|
}
|
|
set maxDefaultLoads(num) {
|
|
this.assetManager.maxDefaultLoads = num;
|
|
}
|
|
get maxDefaultLoads() {
|
|
return this.assetManager.maxDefaultLoads;
|
|
}
|
|
deleteCache(cacheId) {
|
|
this.assetManager.cache.empty(cacheId);
|
|
return this;
|
|
}
|
|
cached(id, cacheId = this._activeCache) {
|
|
return this.assetManager.cache.read(id, cacheId);
|
|
}
|
|
}
|
|
exports.default = LoaderPlugin;
|
|
|
|
},{"./AssetManager":3,"./AssetToken":4,"./AssetUtils":5,"./errors/LoaderError":7,"./tasks/FunctionTask":17,"./tasks/ListTask":18,"./tasks/LoadTask":19,"./tasks/Task":20}],7:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
class LoaderError extends Error {
|
|
constructor(originalError, request, message) {
|
|
message = message ? message + ': ' + originalError.message : originalError.message;
|
|
super(message);
|
|
this.originalError = originalError;
|
|
this.request = request;
|
|
Object.setPrototypeOf(this, LoaderError.prototype);
|
|
this.name = 'LoaderError';
|
|
this.message = message || 'load error';
|
|
this.stack = new Error().stack;
|
|
}
|
|
toString() {
|
|
return this.name + ': ' + this.message;
|
|
}
|
|
}
|
|
exports.default = LoaderError;
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
"use strict";
|
|
function __export(m) {
|
|
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
|
|
}
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
__export(require("./LoaderError"));
|
|
var LoaderError_1 = require("./LoaderError");
|
|
exports.LoaderError = LoaderError_1.default;
|
|
|
|
},{"./LoaderError":7}],9:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const LoaderError_1 = require("../errors/LoaderError");
|
|
const path = require("path");
|
|
var FILETYPE;
|
|
(function (FILETYPE) {
|
|
FILETYPE.IMAGE = 'image';
|
|
FILETYPE.BINARY = 'binary';
|
|
FILETYPE.JSON = 'json';
|
|
FILETYPE.XML = 'xml';
|
|
FILETYPE.CSS = 'css';
|
|
FILETYPE.JAVASCRIPT = 'js';
|
|
FILETYPE.SVG = 'svg';
|
|
FILETYPE.TEXT = 'text';
|
|
FILETYPE.HTML = 'html';
|
|
})(FILETYPE = exports.FILETYPE || (exports.FILETYPE = {}));
|
|
class AbstractLoader {
|
|
prepare(url) {
|
|
return url;
|
|
}
|
|
load(uri, callback, options) {
|
|
let type = this.getFileType(uri);
|
|
if (options && options.format) {
|
|
type = options.format;
|
|
}
|
|
this.internalLoad(type, uri, callback, options);
|
|
}
|
|
internalLoad(type, uri, callback, options) {
|
|
}
|
|
createError(err, uri, message) {
|
|
return new LoaderError_1.default(typeof err === 'string' ? new Error(err) : err, uri, message);
|
|
}
|
|
internalDone(type, uri, data, callback) {
|
|
switch (type) {
|
|
case FILETYPE.SVG:
|
|
this.parseDOM('image/svg+xml', uri, data, callback);
|
|
break;
|
|
case FILETYPE.XML:
|
|
this.parseDOM('application/xml', uri, data, callback);
|
|
break;
|
|
case FILETYPE.HTML:
|
|
this.parseDOM('text/html', uri, data, callback);
|
|
break;
|
|
case FILETYPE.CSS:
|
|
this.parseStyle(data, callback);
|
|
break;
|
|
case FILETYPE.JSON:
|
|
this.parseJSON(uri, data, callback);
|
|
break;
|
|
default:
|
|
callback(null, data);
|
|
break;
|
|
}
|
|
}
|
|
parseDOM(parseType, uri, data, callback) {
|
|
try {
|
|
const parser = new DOMParser();
|
|
const object = parser.parseFromString(data, parseType);
|
|
callback(null, object);
|
|
}
|
|
catch (e) {
|
|
callback(this.createError(e, uri));
|
|
}
|
|
}
|
|
parseStyle(data, callback) {
|
|
const style = document.createElement('style');
|
|
style.type = 'text/css';
|
|
style.innerHTML = data;
|
|
callback(null, style);
|
|
}
|
|
parseJSON(uri, data, callback) {
|
|
try {
|
|
data = JSON.parse(data);
|
|
}
|
|
catch (e) {
|
|
return callback(this.createError(e, uri, 'Failed to parse JSON'));
|
|
}
|
|
callback(null, data);
|
|
}
|
|
getFileType(uri) {
|
|
const extension = path.extname(uri).toLowerCase();
|
|
switch (extension) {
|
|
case '.jpeg':
|
|
case '.jpg':
|
|
case '.gif':
|
|
case '.png':
|
|
case '.webp':
|
|
case '.bmp':
|
|
return FILETYPE.IMAGE;
|
|
case '.json':
|
|
case '.keys':
|
|
case '.bt':
|
|
case '.assets':
|
|
case '.anim':
|
|
return FILETYPE.JSON;
|
|
case '.xml':
|
|
return FILETYPE.XML;
|
|
case '.css':
|
|
return FILETYPE.CSS;
|
|
case '.js':
|
|
return FILETYPE.JAVASCRIPT;
|
|
case '.svg':
|
|
return FILETYPE.SVG;
|
|
case '.xml':
|
|
return FILETYPE.XML;
|
|
case '.html':
|
|
case '.htm':
|
|
case '.xhtml':
|
|
return FILETYPE.HTML;
|
|
default:
|
|
return FILETYPE.TEXT;
|
|
}
|
|
}
|
|
}
|
|
exports.default = AbstractLoader;
|
|
|
|
},{"../errors/LoaderError":7,"path":undefined}],10:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const jibo_plugins_1 = require("jibo-plugins");
|
|
const AbstractLoader_1 = require("./AbstractLoader");
|
|
const path = require("path");
|
|
const fs = require("fs");
|
|
var MIMETYPE;
|
|
(function (MIMETYPE) {
|
|
MIMETYPE.jpg = 'image/jpeg';
|
|
MIMETYPE.jpeg = 'image/jpeg';
|
|
MIMETYPE.gif = 'image/gif';
|
|
MIMETYPE.png = 'image/png';
|
|
MIMETYPE.bmp = 'image/bmp';
|
|
MIMETYPE.webp = 'image/webp';
|
|
})(MIMETYPE || (MIMETYPE = {}));
|
|
class LocalLoader extends AbstractLoader_1.default {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.basePath = '';
|
|
}
|
|
prepare(uri) {
|
|
if (!path.isAbsolute(uri) && !/^(https?|file)\:\/\//.test(uri)) {
|
|
uri = jibo_plugins_1.PathUtils.getAssetUri(uri, undefined, this.basePath);
|
|
uri = path.resolve(uri);
|
|
}
|
|
return uri;
|
|
}
|
|
internalLoad(type, uri, callback, options) {
|
|
if (!path.isAbsolute(uri)) {
|
|
uri = jibo_plugins_1.PathUtils.getAssetUri(uri, undefined, this.basePath);
|
|
uri = path.resolve(uri);
|
|
}
|
|
fs.readFile(uri, this.getEncodingType(type), (err, data) => {
|
|
if (err) {
|
|
return callback(this.createError(err, uri, `Unable to read ${type} file at ${uri}`));
|
|
}
|
|
switch (type) {
|
|
case AbstractLoader_1.FILETYPE.IMAGE:
|
|
const mimeType = this.getImageMimeType(uri);
|
|
const result = new Image();
|
|
result.src = `data:${mimeType};base64,${data}`;
|
|
callback(null, result);
|
|
break;
|
|
case AbstractLoader_1.FILETYPE.JAVASCRIPT:
|
|
try {
|
|
const result = require(uri);
|
|
callback(null, result);
|
|
}
|
|
catch (e) {
|
|
callback(this.createError(e, uri, 'Unable to read JavaScript file'));
|
|
}
|
|
break;
|
|
default:
|
|
this.internalDone(type, uri, data, callback);
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
getEncodingType(type) {
|
|
switch (type) {
|
|
case AbstractLoader_1.FILETYPE.IMAGE:
|
|
return 'base64';
|
|
case AbstractLoader_1.FILETYPE.JSON:
|
|
case AbstractLoader_1.FILETYPE.CSS:
|
|
case AbstractLoader_1.FILETYPE.XML:
|
|
case AbstractLoader_1.FILETYPE.SVG:
|
|
case AbstractLoader_1.FILETYPE.HTML:
|
|
case AbstractLoader_1.FILETYPE.TEXT:
|
|
default:
|
|
return 'utf8';
|
|
}
|
|
}
|
|
getImageMimeType(uri) {
|
|
let extension = path.extname(uri).toLowerCase();
|
|
if (extension) {
|
|
extension = extension.substr(1);
|
|
}
|
|
return MIMETYPE[extension] || null;
|
|
}
|
|
}
|
|
exports.default = LocalLoader;
|
|
|
|
},{"./AbstractLoader":9,"fs":undefined,"jibo-plugins":undefined,"path":undefined}],11:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const AbstractLoader_1 = require("./AbstractLoader");
|
|
const ImageResource_1 = require("./remote/ImageResource");
|
|
const TextResource_1 = require("./remote/TextResource");
|
|
const BinaryResource_1 = require("./remote/BinaryResource");
|
|
class RemoteLoader extends AbstractLoader_1.default {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.baseUrl = '';
|
|
}
|
|
prepare(url) {
|
|
if (this.baseUrl.length
|
|
&& this.baseUrl.lastIndexOf('/') !== this.baseUrl.length - 1
|
|
&& url.charAt(0) !== '/') {
|
|
return this.baseUrl + '/' + url;
|
|
}
|
|
return this.baseUrl + url;
|
|
}
|
|
internalLoad(type, url, callback, options) {
|
|
options = options || {};
|
|
let resource;
|
|
if (type === AbstractLoader_1.FILETYPE.IMAGE) {
|
|
resource = new ImageResource_1.default(type, url, callback, options);
|
|
}
|
|
else if (type === AbstractLoader_1.FILETYPE.BINARY) {
|
|
resource = new BinaryResource_1.default(type, url, callback, options);
|
|
}
|
|
else {
|
|
resource = new TextResource_1.default(type, url, callback, options);
|
|
}
|
|
resource.onComplete = (err, resource) => {
|
|
if (err) {
|
|
return resource.callback(this.createError(err, url));
|
|
}
|
|
if (resource.type === AbstractLoader_1.FILETYPE.JAVASCRIPT) {
|
|
const script = document.createElement('script');
|
|
script.innerHTML = String(resource.result);
|
|
script.dataset['url'] = resource.url;
|
|
resource.callback(null, script);
|
|
}
|
|
else if (resource.type === AbstractLoader_1.FILETYPE.IMAGE) {
|
|
resource.callback(null, resource.result);
|
|
}
|
|
else {
|
|
this.internalDone(resource.type, resource.url, resource.result, resource.callback);
|
|
}
|
|
};
|
|
resource.start();
|
|
}
|
|
}
|
|
exports.default = RemoteLoader;
|
|
|
|
},{"./AbstractLoader":9,"./remote/BinaryResource":12,"./remote/ImageResource":13,"./remote/TextResource":15}],12:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const http = require("http");
|
|
const Resource_1 = require("./Resource");
|
|
class BinaryResource extends Resource_1.default {
|
|
start() {
|
|
http.get(this.url, (res) => {
|
|
const data = [];
|
|
res.on('data', (chunk) => {
|
|
data.push(chunk);
|
|
}).on('end', () => {
|
|
this.result = Buffer.concat(data);
|
|
this.complete();
|
|
}).on('error', (e) => {
|
|
this.complete(e);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
exports.default = BinaryResource;
|
|
|
|
},{"./Resource":14,"http":undefined}],13:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const Resource_1 = require("./Resource");
|
|
class ImageResource extends Resource_1.default {
|
|
constructor(type, url, callback, options) {
|
|
super(type, url, callback, options);
|
|
this.onError = this.onError.bind(this);
|
|
this.onLoad = this.onLoad.bind(this);
|
|
this.onTimeout = this.onTimeout.bind(this);
|
|
const result = this.result = new Image();
|
|
options = options || {};
|
|
if (options.crossOrigin) {
|
|
result.crossOrigin = options.crossOrigin;
|
|
}
|
|
result.addEventListener('error', this.onError, false);
|
|
result.addEventListener('load', this.onLoad, false);
|
|
if (options.timeout) {
|
|
this.timeoutId = setTimeout(this.onTimeout, options.timeout);
|
|
}
|
|
}
|
|
destroy() {
|
|
if (this.timeoutId) {
|
|
clearTimeout(this.timeoutId);
|
|
this.timeoutId = null;
|
|
}
|
|
if (this.result) {
|
|
this.result.removeEventListener('error', this.onError);
|
|
this.result.removeEventListener('load', this.onLoad);
|
|
}
|
|
this.onError = null;
|
|
this.onLoad = null;
|
|
this.onTimeout = null;
|
|
this.result = null;
|
|
super.destroy();
|
|
}
|
|
start() {
|
|
this.result.src = this.url;
|
|
}
|
|
onError() {
|
|
this.complete('Failed to load element using <IMG>');
|
|
}
|
|
onLoad() {
|
|
this.complete();
|
|
}
|
|
}
|
|
exports.default = ImageResource;
|
|
|
|
},{"./Resource":14}],14:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
class Resource {
|
|
constructor(type, url, callback, options) {
|
|
this.type = type;
|
|
this.url = url;
|
|
this.callback = callback;
|
|
this.options = options;
|
|
this.options = options || {};
|
|
}
|
|
start() {
|
|
}
|
|
complete(err) {
|
|
this.onComplete(err, this);
|
|
this.destroy();
|
|
}
|
|
onTimeout() {
|
|
this.complete('Request timed out.');
|
|
}
|
|
destroy() {
|
|
this.onComplete = null;
|
|
this.callback = null;
|
|
this.result = null;
|
|
this.options = null;
|
|
this.url = null;
|
|
this.type = null;
|
|
}
|
|
}
|
|
exports.default = Resource;
|
|
|
|
},{}],15:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const Resource_1 = require("./Resource");
|
|
const STATUS_NONE = 0;
|
|
const STATUS_OK = 200;
|
|
const STATUS_EMPTY = 204;
|
|
class TextResource extends Resource_1.default {
|
|
constructor(type, url, callback, options) {
|
|
super(type, url, callback, options);
|
|
this.onError = this.onError.bind(this);
|
|
this.onAbort = this.onAbort.bind(this);
|
|
this.onLoad = this.onLoad.bind(this);
|
|
this.onTimeout = this.onTimeout.bind(this);
|
|
const request = new XMLHttpRequest();
|
|
request.responseType = 'text';
|
|
options = options || {};
|
|
if (options.timeout) {
|
|
request.timeout = options.timeout;
|
|
request.addEventListener('timeout', this.onTimeout, false);
|
|
}
|
|
request.addEventListener('error', this.onError, false);
|
|
request.addEventListener('abort', this.onAbort, false);
|
|
request.addEventListener('load', this.onLoad, false);
|
|
this.request = request;
|
|
}
|
|
start() {
|
|
this.request.open('GET', this.url, true);
|
|
this.request.send();
|
|
}
|
|
destroy() {
|
|
super.destroy();
|
|
if (this.request) {
|
|
this.request.removeEventListener('error', this.onError);
|
|
this.request.removeEventListener('abort', this.onAbort);
|
|
this.request.removeEventListener('load', this.onLoad);
|
|
this.request.removeEventListener('timeout', this.onTimeout);
|
|
}
|
|
this.onError = null;
|
|
this.onAbort = null;
|
|
this.onLoad = null;
|
|
this.onTimeout = null;
|
|
this.request = null;
|
|
}
|
|
onLoad() {
|
|
const request = this.request;
|
|
const status = request.status;
|
|
if (status === STATUS_OK || status === STATUS_EMPTY || (status === STATUS_NONE && request.responseText.length > 0)) {
|
|
this.result = request.response || request.responseText;
|
|
}
|
|
else {
|
|
return this.complete('[' + request.status + ']' + request.statusText + ':' + request.responseURL);
|
|
}
|
|
this.complete();
|
|
}
|
|
onError() {
|
|
this.complete(this.reqType() + ' Request failed. '
|
|
+ 'Status: ' + this.request.status + ', text: "' + this.request.statusText + '"');
|
|
}
|
|
onAbort() {
|
|
this.complete(this.reqType() + ' Request was aborted by the user.');
|
|
}
|
|
reqType() {
|
|
return this.request.toString().replace('object ', '');
|
|
}
|
|
}
|
|
exports.default = TextResource;
|
|
|
|
},{"./Resource":14}],16:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const jibo_log_1 = require("jibo-log");
|
|
exports.default = new jibo_log_1.Log('Jibo.Loader');
|
|
|
|
},{"jibo-log":undefined}],17:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const Task_1 = require("./Task");
|
|
class FunctionTask extends Task_1.default {
|
|
static test(asset) {
|
|
return !!asset.async;
|
|
}
|
|
constructor(manager, asset) {
|
|
super(manager, asset);
|
|
this.async = asset.async;
|
|
}
|
|
start(callback) {
|
|
this.async(callback);
|
|
}
|
|
destroy() {
|
|
super.destroy();
|
|
this.async = null;
|
|
}
|
|
}
|
|
exports.default = FunctionTask;
|
|
|
|
},{"./Task":20}],18:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const Task_1 = require("./Task");
|
|
const AssetUtils_1 = require("../AssetUtils");
|
|
class ListTask extends Task_1.default {
|
|
static test(asset) {
|
|
return !!asset.assets && (Array.isArray(asset.assets) || AssetUtils_1.default.isPlain(asset.assets));
|
|
}
|
|
constructor(manager, asset) {
|
|
super(manager, asset);
|
|
this.assets = asset.assets;
|
|
this.cacheAll = asset.cacheAll;
|
|
this.remoteAll = asset.remoteAll;
|
|
this.progress = asset.progress;
|
|
}
|
|
start(callback) {
|
|
this.load(this.assets, {
|
|
complete: callback,
|
|
progress: this.progress,
|
|
cacheAll: this.cacheAll,
|
|
remoteAll: this.remoteAll
|
|
});
|
|
}
|
|
destroy() {
|
|
super.destroy();
|
|
this.assets = null;
|
|
}
|
|
}
|
|
exports.default = ListTask;
|
|
|
|
},{"../AssetUtils":5,"./Task":20}],19:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const Task_1 = require("./Task");
|
|
class LoadTask extends Task_1.default {
|
|
static test(asset) {
|
|
return !!asset.src;
|
|
}
|
|
constructor(manager, asset) {
|
|
super(manager, asset, asset.src);
|
|
this.src = this.prepare(asset.src);
|
|
}
|
|
start(callback) {
|
|
this.simpleLoad(this.src, callback, {
|
|
remote: this.remote,
|
|
timeout: this.timeout,
|
|
format: this.format
|
|
});
|
|
}
|
|
}
|
|
exports.default = LoadTask;
|
|
|
|
},{"./Task":20}],20:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const AssetManager_1 = require("../AssetManager");
|
|
const path = require("path");
|
|
const log_1 = require("../log");
|
|
const log = log_1.default.createChild('Task');
|
|
class Task {
|
|
constructor(manager, asset, fallbackId) {
|
|
this.manager = manager;
|
|
this.pending = null;
|
|
this.status = Task.WAITING;
|
|
this.complete = asset.complete || null;
|
|
this.cache = asset.cache === undefined ? null : asset.cache;
|
|
this.id = asset.id || null;
|
|
this.remote = asset.remote === undefined ? false : asset.remote;
|
|
this.timeout = asset.timeout || 0;
|
|
this.format = asset.format || null;
|
|
this.original = asset;
|
|
if (this.cache && !this.id) {
|
|
if (fallbackId && typeof fallbackId === "string") {
|
|
asset.id = this.id = path.parse(fallbackId).name;
|
|
}
|
|
if (!this.id) {
|
|
log.debug("Caching an asset requires an id, none set", asset);
|
|
this.cache = null;
|
|
}
|
|
}
|
|
this.cacheKey = AssetManager_1.getCacheKeyFromAsset(asset, this.manager);
|
|
this.needsCache = false;
|
|
this.subAssets = [];
|
|
this.token = null;
|
|
}
|
|
start(callback) {
|
|
}
|
|
load(source, options) {
|
|
if (typeof options === "function") {
|
|
options = { complete: options };
|
|
}
|
|
const load = this.manager.load(source, options);
|
|
if (this.cache) {
|
|
this.subAssets.push(...load.tokens);
|
|
}
|
|
return load;
|
|
}
|
|
simpleLoad(url, complete, options) {
|
|
this.manager.simpleLoad(url, complete, options || {
|
|
remote: this.remote,
|
|
timeout: this.timeout,
|
|
format: this.format
|
|
});
|
|
}
|
|
prepare(uri) {
|
|
return this.manager.prepare(uri, this.remote);
|
|
}
|
|
destroy() {
|
|
this.pending = null;
|
|
this.manager = null;
|
|
this.status = Task.FINISHED;
|
|
this.id = null;
|
|
this.complete = null;
|
|
this.original = null;
|
|
}
|
|
}
|
|
Task.WAITING = 0;
|
|
Task.RUNNING = 1;
|
|
Task.FINISHED = 2;
|
|
exports.default = Task;
|
|
|
|
},{"../AssetManager":3,"../log":16,"path":undefined}],21:[function(require,module,exports){
|
|
"use strict";
|
|
function __export(m) {
|
|
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
|
|
}
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
__export(require("./FunctionTask"));
|
|
__export(require("./ListTask"));
|
|
__export(require("./LoadTask"));
|
|
__export(require("./Task"));
|
|
var FunctionTask_1 = require("./FunctionTask");
|
|
exports.FunctionTask = FunctionTask_1.default;
|
|
var ListTask_1 = require("./ListTask");
|
|
exports.ListTask = ListTask_1.default;
|
|
var LoadTask_1 = require("./LoadTask");
|
|
exports.LoadTask = LoadTask_1.default;
|
|
var Task_1 = require("./Task");
|
|
exports.Task = Task_1.default;
|
|
|
|
},{"./FunctionTask":17,"./ListTask":18,"./LoadTask":19,"./Task":20}],22:[function(require,module,exports){
|
|
"use strict";
|
|
function __export(m) {
|
|
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
|
|
}
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
__export(require("./tasks"));
|
|
__export(require("./errors"));
|
|
__export(require("./AssetCache"));
|
|
__export(require("./AssetLoad"));
|
|
__export(require("./AssetManager"));
|
|
__export(require("./AssetUtils"));
|
|
__export(require("./LoaderPlugin"));
|
|
var AssetLoad_1 = require("./AssetLoad");
|
|
exports.AssetLoad = AssetLoad_1.default;
|
|
var AssetToken_1 = require("./AssetToken");
|
|
exports.AssetToken = AssetToken_1.default;
|
|
var AssetManager_1 = require("./AssetManager");
|
|
exports.AssetManager = AssetManager_1.default;
|
|
var AssetUtils_1 = require("./AssetUtils");
|
|
exports.AssetUtils = AssetUtils_1.default;
|
|
var LoaderPlugin_1 = require("./LoaderPlugin");
|
|
exports.LoaderPlugin = LoaderPlugin_1.default;
|
|
|
|
},{"./AssetCache":1,"./AssetLoad":2,"./AssetManager":3,"./AssetToken":4,"./AssetUtils":5,"./LoaderPlugin":6,"./errors":8,"./tasks":21}]},{},[22])(22)
|
|
});
|
|
|
|
//# sourceMappingURL=jibo-loader.js.map
|