Source: resolvers/PathResolver.js

import { Utils } from '../common/Utils';
import { BaseResolver } from './BaseResolver';

const __ = {
	private: Symbol('private'),
}
function _initPrivateMembers(that, param) {
	that[__.private] = {};
	const _private = that[__.private];

	_private.init = (param) => {
		if (!param ||
			!Utils.isFunction(param.getOptions) ||
			!Utils.isFunction(param.getBaseURL) ||
			!Utils.isFunction(param.getCurrentPath)) {
			Utils.error("the param is invalid");
			return;
		}
		_private.getOptions = param.getOptions;
		_private.getBaseURL = param.getBaseURL;
		_private.getCurrentPath = param.getCurrentPath;
	}
	_private.init(param);
}

/**
 * @class PathResolver
 * The base resolver
 * @memberof THING.EXTEND
 * @extends THING.EXTEND.BaseResolver
 */
class PathResolver extends BaseResolver {

	constructor(param = {}) {
		super();
		_initPrivateMembers(this, param);
	}

	getBaseURL() {
		let _private = this[__.private];
		let options = _private.getOptions();
		let baseURL = _private.getBaseURL();
		return options['baseURL'] || baseURL;
	}
	resolveURL(url) {
		let _private = this[__.private];

		if (url._startsWith('http://') || url._startsWith('https://') || url._startsWith('/')) {
			return url;
		}
		else if (url._startsWith('.')) {
			let currentPath = _private.getCurrentPath()
			if (currentPath) {
				return currentPath._appendURL(url);
			}
			else {
				return url;
			}
		}
		return null;
	}
	resolveTextureURL(url) {
		let textureURL = this.resolveURL(url);
		if (!textureURL) {
			let rootPath = this.getBaseURL();
			textureURL = rootPath._appendPath(url);
		}
		return textureURL;
	}
	resolveModelURL(url) {
		let _private = this[__.private];
		let options = _private.getOptions()

		let modelURL = this.resolveURL(url);
		if (!modelURL) {
			let rootPath = this.getBaseURL();
			let uri = url;
			if (options.onModelURIProcess) {
				uri = options.onModelURIProcess(url);
			}
			modelURL = rootPath._appendPath(uri);
		}
		return modelURL;
	}

}

export { PathResolver }