universal-geocoder
Version:
Universal geocoding abstraction server-side and client-side with multiple built-in providers
204 lines • 9.82 kB
JavaScript
;
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.defaultChainProviderOptions = void 0;
var provider_1 = require("./");
exports.defaultChainProviderOptions = __assign(__assign({}, provider_1.defaultProviderOptions), { providers: [] });
var ChainProvider = /** @class */ (function () {
function ChainProvider(options) {
if (options === void 0) { options = exports.defaultChainProviderOptions; }
this.options = options;
}
ChainProvider.prototype.geocode = function (query, callback, errorCallback) {
var _this = this;
if (this.options.parallelize || this.options.first) {
if (!callback) {
return new Promise(function (resolve, reject) {
return _this.geocodeAllProviders(query, function (results) { return resolve(results); }, function (error) { return reject(error); });
});
}
return this.geocodeAllProviders(query, callback, errorCallback);
}
if (!callback) {
return new Promise(function (resolve, reject) {
return _this.geocodeNextProvider(_this.options.providers, query, function (results) { return resolve(results); }, function (error) { return reject(error); });
});
}
return this.geocodeNextProvider(this.options.providers, query, callback, errorCallback);
};
ChainProvider.prototype.geodecode = function (latitudeOrQuery, longitudeOrCallback, callbackOrErrorCallback, errorCallback) {
var _this = this;
var reverseQuery = provider_1.ProviderHelpers.getReverseQueryFromParameters(latitudeOrQuery, longitudeOrCallback);
var reverseCallback = provider_1.ProviderHelpers.getCallbackFromParameters(longitudeOrCallback, callbackOrErrorCallback);
var reverseErrorCallback = provider_1.ProviderHelpers.getErrorCallbackFromParameters(longitudeOrCallback, callbackOrErrorCallback, errorCallback);
if (this.options.parallelize || this.options.first) {
if (!reverseCallback) {
return new Promise(function (resolve, reject) {
return _this.geodecodeAllProviders(reverseQuery, function (results) { return resolve(results); }, function (error) { return reject(error); });
});
}
return this.geodecodeAllProviders(reverseQuery, reverseCallback, reverseErrorCallback);
}
if (!reverseCallback) {
return new Promise(function (resolve, reject) {
return _this.geodecodeNextProvider(_this.options.providers, reverseQuery, function (results) { return resolve(results); }, function (error) { return reject(error); });
});
}
return this.geodecodeNextProvider(this.options.providers, reverseQuery, reverseCallback, reverseErrorCallback);
};
ChainProvider.prototype.geocodeNextProvider = function (providers, query, callback, errorCallback) {
var _this = this;
var provider = providers[0], nextProviders = providers.slice(1);
var resultCallback = function (results) {
if (results.length > 0) {
callback(results);
return;
}
_this.geocodeNextProvider(nextProviders, query, callback, errorCallback);
};
var resultErrorCallback = function (responseError) {
if (errorCallback) {
errorCallback(responseError);
}
if (!errorCallback) {
// eslint-disable-next-line no-console
console.error("An error has occurred when geocoding with the provider " + provider.constructor.name, responseError);
}
resultCallback([]);
};
provider.geocode(query, resultCallback, resultErrorCallback);
};
ChainProvider.prototype.geodecodeNextProvider = function (providers, reverseQuery, callback, errorCallback) {
var _this = this;
var provider = providers[0], nextProviders = providers.slice(1);
var resultCallback = function (results) {
if (results.length > 0) {
callback(results);
return;
}
_this.geodecodeNextProvider(nextProviders, reverseQuery, callback, errorCallback);
};
var resultErrorCallback = function (responseError) {
if (errorCallback) {
errorCallback(responseError);
}
if (!errorCallback) {
// eslint-disable-next-line no-console
console.error("An error has occurred when geodecoding with the provider " + provider.constructor.name, responseError);
}
resultCallback([]);
};
provider.geodecode(reverseQuery, resultCallback, resultErrorCallback);
};
ChainProvider.prototype.geocodeAllProviders = function (query, callback, errorCallback) {
var _this = this;
var providerResults = new Map();
var callbackCalled = false;
var getProviderResult = function () {
return _this.options.providers.reduce(function (result, provider) {
var providerResult = result;
if (undefined === providerResult && _this.options.first) {
providerResult = [];
}
if (undefined === providerResult) {
return undefined;
}
if (providerResult.length > 0) {
return providerResult;
}
return providerResults.get(provider.constructor.name);
}, []);
};
var resultProviderCallback = function (providerName) { return function (results) {
providerResults.set(providerName, results);
var providerResult = getProviderResult();
if (!callbackCalled && providerResult) {
callback(providerResult);
callbackCalled = true;
}
}; };
var resultProviderErrorCallback = function (providerName) { return function (responseError) {
if (errorCallback) {
errorCallback(responseError);
}
if (!errorCallback) {
// eslint-disable-next-line no-console
console.error("An error has occurred when geocoding with the provider " + providerName, responseError);
}
resultProviderCallback(providerName)([]);
}; };
this.options.providers.forEach(function (provider) {
var providerName = provider.constructor.name;
provider.geocode(query, resultProviderCallback(providerName), resultProviderErrorCallback(providerName));
});
};
ChainProvider.prototype.geodecodeAllProviders = function (reverseQuery, callback, errorCallback) {
var _this = this;
var providerResults = new Map();
var callbackCalled = false;
var getProviderResult = function () {
return _this.options.providers.reduce(function (result, provider) {
var providerResult = result;
if (undefined === providerResult && _this.options.first) {
providerResult = [];
}
if (undefined === providerResult) {
return undefined;
}
if (providerResult.length > 0) {
return providerResult;
}
return providerResults.get(provider.constructor.name);
}, []);
};
var resultProviderCallback = function (providerName) { return function (results) {
providerResults.set(providerName, results);
var providerResult = getProviderResult();
if (!callbackCalled && providerResult) {
callback(providerResult);
callbackCalled = true;
}
}; };
var resultProviderErrorCallback = function (providerName) { return function (responseError) {
if (errorCallback) {
errorCallback(responseError);
}
if (!errorCallback) {
// eslint-disable-next-line no-console
console.error("An error has occurred when geodecoding with the provider " + providerName, responseError);
}
resultProviderCallback(providerName)([]);
}; };
this.options.providers.forEach(function (provider) {
var providerName = provider.constructor.name;
provider.geodecode(reverseQuery, resultProviderCallback(providerName), resultProviderErrorCallback(providerName));
});
};
// eslint-disable-next-line class-methods-use-this
ChainProvider.prototype.executeRequest = function (
// eslint-disable-next-line @typescript-eslint/no-unused-vars
params,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
callback,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
headers,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
body,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
errorCallback) {
throw new Error("executeRequest cannot be called directly from the chain provider.");
};
return ChainProvider;
}());
exports.default = ChainProvider;
//# sourceMappingURL=ChainProvider.js.map