LBRYFoundation/lbry-desktop
1
0
Fork 0
mirror of https://github.com/LBRYFoundation/lbry-desktop.git synced 2025-08-31 01:11:26 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

increase wait time for daemon to launch

Browse source
This commit is contained in:
Jeremy Kauffman 2017-06-14 11:21:16 -04:00
parent 84589f1ebb
commit efd289b1ed
1 changed files with 375 additions and 375 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

750
ui/js/lbry.js
View file

@ -1,25 +1,25 @@
import lbryio from './lbryio.js'; import lbryio from "./lbryio.js";
import lighthouse from './lighthouse.js'; import lighthouse from "./lighthouse.js";
import jsonrpc from './jsonrpc.js'; import jsonrpc from "./jsonrpc.js";
import lbryuri from './lbryuri.js'; import lbryuri from "./lbryuri.js";
import { getLocal, getSession, setSession, setLocal } from './utils.js'; import { getLocal, getSession, setSession, setLocal } from "./utils.js";
const { remote, ipcRenderer } = require('electron'); const { remote, ipcRenderer } = require("electron");
const menu = remote.require('./menu/main-menu'); const menu = remote.require("./menu/main-menu");
let lbry = { let lbry = {
isConnected: false, isConnected: false,
daemonConnectionString: 'http://localhost:5279/lbryapi', daemonConnectionString: "http://localhost:5279/lbryapi",
pendingPublishTimeout: 20 * 60 * 1000, pendingPublishTimeout: 20 * 60 * 1000,
defaultClientSettings: { defaultClientSettings: {
showNsfw: false, showNsfw: false,
showUnavailable: true, showUnavailable: true,
debug: false, debug: false,
useCustomLighthouseServers: false, useCustomLighthouseServers: false,
customLighthouseServers: [], customLighthouseServers: [],
showDeveloperMenu: false, showDeveloperMenu: false,
language: 'en' language: "en",
} },
}; };
/** /**
@ -27,24 +27,24 @@ let lbry = {
* needed to make a dummy claim or file info object. * needed to make a dummy claim or file info object.
*/ */
function savePendingPublish({ name, channel_name }) { function savePendingPublish({ name, channel_name }) {
let uri; let uri;
if (channel_name) { if (channel_name) {
uri = lbryuri.build({ name: channel_name, path: name }, false); uri = lbryuri.build({ name: channel_name, path: name }, false);
} else { } else {
uri = lbryuri.build({ name: name }, false); uri = lbryuri.build({ name: name }, false);
} }
const pendingPublishes = getLocal('pendingPublishes') || []; const pendingPublishes = getLocal("pendingPublishes") || [];
const newPendingPublish = { const newPendingPublish = {
name, name,
channel_name, channel_name,
claim_id: 'pending_claim_' + uri, claim_id: "pending_claim_" + uri,
txid: 'pending_' + uri, txid: "pending_" + uri,
nout: 0, nout: 0,
outpoint: 'pending_' + uri + ':0', outpoint: "pending_" + uri + ":0",
time: Date.now() time: Date.now(),
}; };
setLocal('pendingPublishes', [...pendingPublishes, newPendingPublish]); setLocal("pendingPublishes", [...pendingPublishes, newPendingPublish]);
return newPendingPublish; return newPendingPublish;
} }
/** /**
@ -52,18 +52,18 @@ function savePendingPublish({ name, channel_name }) {
* A channel name may also be provided along with name. * A channel name may also be provided along with name.
*/ */
function removePendingPublishIfNeeded({ name, channel_name, outpoint }) { function removePendingPublishIfNeeded({ name, channel_name, outpoint }) {
function pubMatches(pub) { function pubMatches(pub) {
return ( return (
pub.outpoint === outpoint || pub.outpoint === outpoint ||
(pub.name === name && (pub.name === name &&
(!channel_name || pub.channel_name === channel_name)) (!channel_name || pub.channel_name === channel_name))
); );
} }
setLocal( setLocal(
'pendingPublishes', "pendingPublishes",
lbry.getPendingPublishes().filter(pub => !pubMatches(pub)) lbry.getPendingPublishes().filter(pub => !pubMatches(pub))
); );
} }
/** /**
@ -71,12 +71,12 @@ function removePendingPublishIfNeeded({ name, channel_name, outpoint }) {
* removes them from the list. * removes them from the list.
*/ */
lbry.getPendingPublishes = function() { lbry.getPendingPublishes = function() {
const pendingPublishes = getLocal('pendingPublishes') || []; const pendingPublishes = getLocal("pendingPublishes") || [];
const newPendingPublishes = pendingPublishes.filter( const newPendingPublishes = pendingPublishes.filter(
pub => Date.now() - pub.time <= lbry.pendingPublishTimeout pub => Date.now() - pub.time <= lbry.pendingPublishTimeout
); );
setLocal('pendingPublishes', newPendingPublishes); setLocal("pendingPublishes", newPendingPublishes);
return newPendingPublishes; return newPendingPublishes;
}; };
/** /**
@ -84,97 +84,97 @@ lbry.getPendingPublishes = function() {
* provided along withe the name. If no pending publish is found, returns null. * provided along withe the name. If no pending publish is found, returns null.
*/ */
function getPendingPublish({ name, channel_name, outpoint }) { function getPendingPublish({ name, channel_name, outpoint }) {
const pendingPublishes = lbry.getPendingPublishes(); const pendingPublishes = lbry.getPendingPublishes();
return ( return (
pendingPublishes.find( pendingPublishes.find(
pub => pub =>
pub.outpoint === outpoint || pub.outpoint === outpoint ||
(pub.name === name && (pub.name === name &&
(!channel_name || pub.channel_name === channel_name)) (!channel_name || pub.channel_name === channel_name))
) || null ) || null
); );
} }
function pendingPublishToDummyClaim({ function pendingPublishToDummyClaim({
channel_name, channel_name,
name, name,
outpoint, outpoint,
claim_id, claim_id,
txid, txid,
nout nout,
}) { }) {
return { name, outpoint, claim_id, txid, nout, channel_name }; return { name, outpoint, claim_id, txid, nout, channel_name };
} }
function pendingPublishToDummyFileInfo({ name, outpoint, claim_id }) { function pendingPublishToDummyFileInfo({ name, outpoint, claim_id }) {
return { name, outpoint, claim_id, metadata: null }; return { name, outpoint, claim_id, metadata: null };
} }
lbry.call = function( lbry.call = function(
method, method,
params, params,
callback, callback,
errorCallback, errorCallback,
connectFailedCallback connectFailedCallback
) { ) {
return jsonrpc.call( return jsonrpc.call(
lbry.daemonConnectionString, lbry.daemonConnectionString,
method, method,
params, params,
callback, callback,
errorCallback, errorCallback,
connectFailedCallback connectFailedCallback
); );
}; };
//core //core
lbry._connectPromise = null; lbry._connectPromise = null;
lbry.connect = function() { lbry.connect = function() {
if (lbry._connectPromise === null) { if (lbry._connectPromise === null) {
lbry._connectPromise = new Promise((resolve, reject) => { lbry._connectPromise = new Promise((resolve, reject) => {
let tryNum = 0; let tryNum = 0;
function checkDaemonStartedFailed() { function checkDaemonStartedFailed() {
if (tryNum <= 100) { if (tryNum <= 200) {
// Move # of tries into constant or config option // Move # of tries into constant or config option
setTimeout(() => { setTimeout(() => {
tryNum++; tryNum++;
checkDaemonStarted(); checkDaemonStarted();
}, tryNum < 50 ? 400 : 1000); }, tryNum < 50 ? 400 : 1000);
} else { } else {
reject(new Error('Unable to connect to LBRY')); reject(new Error("Unable to connect to LBRY"));
} }
} }
// Check every half second to see if the daemon is accepting connections // Check every half second to see if the daemon is accepting connections
function checkDaemonStarted() { function checkDaemonStarted() {
lbry.call( lbry.call(
'status', "status",
{}, {},
resolve, resolve,
checkDaemonStartedFailed, checkDaemonStartedFailed,
checkDaemonStartedFailed checkDaemonStartedFailed
); );
} }
checkDaemonStarted(); checkDaemonStarted();
}); });
} }
return lbry._connectPromise; return lbry._connectPromise;
}; };
lbry.checkAddressIsMine = function(address, callback) { lbry.checkAddressIsMine = function(address, callback) {
lbry.call('wallet_is_address_mine', { address: address }, callback); lbry.call("wallet_is_address_mine", { address: address }, callback);
}; };
lbry.sendToAddress = function(amount, address, callback, errorCallback) { lbry.sendToAddress = function(amount, address, callback, errorCallback) {
lbry.call( lbry.call(
'send_amount_to_address', "send_amount_to_address",
{ amount: amount, address: address }, { amount: amount, address: address },
callback, callback,
errorCallback errorCallback
); );
}; };
/** /**
@ -189,46 +189,46 @@ lbry.sendToAddress = function(amount, address, callback, errorCallback) {
*/ */
lbry.costPromiseCache = {}; lbry.costPromiseCache = {};
lbry.getCostInfo = function(uri) { lbry.getCostInfo = function(uri) {
if (lbry.costPromiseCache[uri] === undefined) { if (lbry.costPromiseCache[uri] === undefined) {
lbry.costPromiseCache[uri] = new Promise((resolve, reject) => { lbry.costPromiseCache[uri] = new Promise((resolve, reject) => {
const COST_INFO_CACHE_KEY = 'cost_info_cache'; const COST_INFO_CACHE_KEY = "cost_info_cache";
let costInfoCache = getSession(COST_INFO_CACHE_KEY, {}); let costInfoCache = getSession(COST_INFO_CACHE_KEY, {});
function cacheAndResolve(cost, includesData) { function cacheAndResolve(cost, includesData) {
costInfoCache[uri] = { cost, includesData }; costInfoCache[uri] = { cost, includesData };
setSession(COST_INFO_CACHE_KEY, costInfoCache); setSession(COST_INFO_CACHE_KEY, costInfoCache);
resolve({ cost, includesData }); resolve({ cost, includesData });
} }
if (!uri) { if (!uri) {
return reject(new Error(`URI required.`)); return reject(new Error(`URI required.`));
} }
if (costInfoCache[uri] && costInfoCache[uri].cost) { if (costInfoCache[uri] && costInfoCache[uri].cost) {
return resolve(costInfoCache[uri]); return resolve(costInfoCache[uri]);
} }
function getCost(uri, size) { function getCost(uri, size) {
lbry lbry
.stream_cost_estimate({ uri, ...(size !== null ? { size } : {}) }) .stream_cost_estimate({ uri, ...(size !== null ? { size } : {}) })
.then(cost => { .then(cost => {
cacheAndResolve(cost, size !== null); cacheAndResolve(cost, size !== null);
}, reject); }, reject);
} }
const uriObj = lbryuri.parse(uri); const uriObj = lbryuri.parse(uri);
const name = uriObj.path || uriObj.name; const name = uriObj.path || uriObj.name;
lighthouse.get_size_for_name(name).then(size => { lighthouse.get_size_for_name(name).then(size => {
if (size) { if (size) {
getCost(name, size); getCost(name, size);
} else { } else {
getCost(name, null); getCost(name, null);
} }
}); });
}); });
} }
return lbry.costPromiseCache[uri]; return lbry.costPromiseCache[uri];
}; };
/** /**
@ -239,143 +239,143 @@ lbry.getCostInfo = function(uri) {
* publish can appear in the UI immediately. * publish can appear in the UI immediately.
*/ */
lbry.publish = function( lbry.publish = function(
params, params,
fileListedCallback, fileListedCallback,
publishedCallback, publishedCallback,
errorCallback errorCallback
) { ) {
lbry.call( lbry.call(
'publish', "publish",
params, params,
result => { result => {
if (returnedPending) { if (returnedPending) {
return; return;
} }
clearTimeout(returnPendingTimeout); clearTimeout(returnPendingTimeout);
publishedCallback(result); publishedCallback(result);
}, },
err => { err => {
if (returnedPending) { if (returnedPending) {
return; return;
} }
clearTimeout(returnPendingTimeout); clearTimeout(returnPendingTimeout);
errorCallback(err); errorCallback(err);
} }
); );
let returnedPending = false; let returnedPending = false;
// Give a short grace period in case publish() returns right away or (more likely) gives an error // Give a short grace period in case publish() returns right away or (more likely) gives an error
const returnPendingTimeout = setTimeout(() => { const returnPendingTimeout = setTimeout(() => {
returnedPending = true; returnedPending = true;
if (publishedCallback) { if (publishedCallback) {
savePendingPublish({ savePendingPublish({
name: params.name, name: params.name,
channel_name: params.channel_name channel_name: params.channel_name,
}); });
publishedCallback(true); publishedCallback(true);
} }
if (fileListedCallback) { if (fileListedCallback) {
const { name, channel_name } = params; const { name, channel_name } = params;
savePendingPublish({ savePendingPublish({
name: params.name, name: params.name,
channel_name: params.channel_name channel_name: params.channel_name,
}); });
fileListedCallback(true); fileListedCallback(true);
} }
}, 2000); }, 2000);
}; };
lbry.getClientSettings = function() { lbry.getClientSettings = function() {
var outSettings = {}; var outSettings = {};
for (let setting of Object.keys(lbry.defaultClientSettings)) { for (let setting of Object.keys(lbry.defaultClientSettings)) {
var localStorageVal = localStorage.getItem('setting_' + setting); var localStorageVal = localStorage.getItem("setting_" + setting);
outSettings[setting] = localStorageVal === null outSettings[setting] = localStorageVal === null
? lbry.defaultClientSettings[setting] ? lbry.defaultClientSettings[setting]
: JSON.parse(localStorageVal); : JSON.parse(localStorageVal);
} }
return outSettings; return outSettings;
}; };
lbry.getClientSetting = function(setting) { lbry.getClientSetting = function(setting) {
var localStorageVal = localStorage.getItem('setting_' + setting); var localStorageVal = localStorage.getItem("setting_" + setting);
if (setting == 'showDeveloperMenu') { if (setting == "showDeveloperMenu") {
return true; return true;
} }
return localStorageVal === null return localStorageVal === null
? lbry.defaultClientSettings[setting] ? lbry.defaultClientSettings[setting]
: JSON.parse(localStorageVal); : JSON.parse(localStorageVal);
}; };
lbry.setClientSettings = function(settings) { lbry.setClientSettings = function(settings) {
for (let setting of Object.keys(settings)) { for (let setting of Object.keys(settings)) {
lbry.setClientSetting(setting, settings[setting]); lbry.setClientSetting(setting, settings[setting]);
} }
}; };
lbry.setClientSetting = function(setting, value) { lbry.setClientSetting = function(setting, value) {
return localStorage.setItem('setting_' + setting, JSON.stringify(value)); return localStorage.setItem("setting_" + setting, JSON.stringify(value));
}; };
lbry.getSessionInfo = function(callback) { lbry.getSessionInfo = function(callback) {
lbry.call('status', { session_status: true }, callback); lbry.call("status", { session_status: true }, callback);
}; };
lbry.reportBug = function(message, callback) { lbry.reportBug = function(message, callback) {
lbry.call( lbry.call(
'report_bug', "report_bug",
{ {
message: message message: message,
}, },
callback callback
); );
}; };
//utilities //utilities
lbry.formatCredits = function(amount, precision) { lbry.formatCredits = function(amount, precision) {
return amount.toFixed(precision || 1).replace(/\.?0+$/, ''); return amount.toFixed(precision || 1).replace(/\.?0+$/, "");
}; };
lbry.formatName = function(name) { lbry.formatName = function(name) {
// Converts LBRY name to standard format (all lower case, no special characters, spaces replaced by dashes) // Converts LBRY name to standard format (all lower case, no special characters, spaces replaced by dashes)
name = name.replace('/s+/g', '-'); name = name.replace("/s+/g", "-");
name = name.toLowerCase().replace(/[^a-z0-9\-]/g, ''); name = name.toLowerCase().replace(/[^a-z0-9\-]/g, "");
return name; return name;
}; };
lbry.imagePath = function(file) { lbry.imagePath = function(file) {
return 'img/' + file; return "img/" + file;
}; };
lbry.getMediaType = function(contentType, fileName) { lbry.getMediaType = function(contentType, fileName) {
if (contentType) { if (contentType) {
return /^[^/]+/.exec(contentType)[0]; return /^[^/]+/.exec(contentType)[0];
} else if (fileName) { } else if (fileName) {
var dotIndex = fileName.lastIndexOf('.'); var dotIndex = fileName.lastIndexOf(".");
if (dotIndex == -1) { if (dotIndex == -1) {
return 'unknown'; return "unknown";
} }
var ext = fileName.substr(dotIndex + 1); var ext = fileName.substr(dotIndex + 1);
if (/^mp4|mov|m4v|flv|f4v$/i.test(ext)) { if (/^mp4|mov|m4v|flv|f4v$/i.test(ext)) {
return 'video'; return "video";
} else if (/^mp3|m4a|aac|wav|flac|ogg$/i.test(ext)) { } else if (/^mp3|m4a|aac|wav|flac|ogg$/i.test(ext)) {
return 'audio'; return "audio";
} else if (/^html|htm|pdf|odf|doc|docx|md|markdown|txt$/i.test(ext)) { } else if (/^html|htm|pdf|odf|doc|docx|md|markdown|txt$/i.test(ext)) {
return 'document'; return "document";
} else { } else {
return 'unknown'; return "unknown";
} }
} else { } else {
return 'unknown'; return "unknown";
} }
}; };
lbry.stop = function(callback) { lbry.stop = function(callback) {
lbry.call('stop', {}, callback); lbry.call("stop", {}, callback);
}; };
lbry._subscribeIdCount = 0; lbry._subscribeIdCount = 0;
@ -384,57 +384,57 @@ lbry._balanceSubscribeInterval = 5000;
lbry._balanceUpdateInterval = null; lbry._balanceUpdateInterval = null;
lbry._updateBalanceSubscribers = function() { lbry._updateBalanceSubscribers = function() {
lbry.wallet_balance().then(function(balance) { lbry.wallet_balance().then(function(balance) {
for (let callback of Object.values(lbry._balanceSubscribeCallbacks)) { for (let callback of Object.values(lbry._balanceSubscribeCallbacks)) {
callback(balance); callback(balance);
} }
}); });
if ( if (
!lbry._balanceUpdateInterval && !lbry._balanceUpdateInterval &&
Object.keys(lbry._balanceSubscribeCallbacks).length Object.keys(lbry._balanceSubscribeCallbacks).length
) { ) {
lbry._balanceUpdateInterval = setInterval(() => { lbry._balanceUpdateInterval = setInterval(() => {
lbry._updateBalanceSubscribers(); lbry._updateBalanceSubscribers();
}, lbry._balanceSubscribeInterval); }, lbry._balanceSubscribeInterval);
} }
}; };
lbry.balanceSubscribe = function(callback) { lbry.balanceSubscribe = function(callback) {
const subscribeId = ++lbry._subscribeIdCount; const subscribeId = ++lbry._subscribeIdCount;
lbry._balanceSubscribeCallbacks[subscribeId] = callback; lbry._balanceSubscribeCallbacks[subscribeId] = callback;
lbry._updateBalanceSubscribers(); lbry._updateBalanceSubscribers();
return subscribeId; return subscribeId;
}; };
lbry.balanceUnsubscribe = function(subscribeId) { lbry.balanceUnsubscribe = function(subscribeId) {
delete lbry._balanceSubscribeCallbacks[subscribeId]; delete lbry._balanceSubscribeCallbacks[subscribeId];
if ( if (
lbry._balanceUpdateInterval && lbry._balanceUpdateInterval &&
!Object.keys(lbry._balanceSubscribeCallbacks).length !Object.keys(lbry._balanceSubscribeCallbacks).length
) { ) {
clearInterval(lbry._balanceUpdateInterval); clearInterval(lbry._balanceUpdateInterval);
} }
}; };
lbry.showMenuIfNeeded = function() { lbry.showMenuIfNeeded = function() {
const showingMenu = sessionStorage.getItem('menuShown') || null; const showingMenu = sessionStorage.getItem("menuShown") || null;
const chosenMenu = lbry.getClientSetting('showDeveloperMenu') const chosenMenu = lbry.getClientSetting("showDeveloperMenu")
? 'developer' ? "developer"
: 'normal'; : "normal";
if (chosenMenu != showingMenu) { if (chosenMenu != showingMenu) {
menu.showMenubar(chosenMenu == 'developer'); menu.showMenubar(chosenMenu == "developer");
} }
sessionStorage.setItem('menuShown', chosenMenu); sessionStorage.setItem("menuShown", chosenMenu);
}; };
lbry.getAppVersionInfo = function() { lbry.getAppVersionInfo = function() {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
ipcRenderer.once('version-info-received', (event, versionInfo) => { ipcRenderer.once("version-info-received", (event, versionInfo) => {
resolve(versionInfo); resolve(versionInfo);
}); });
ipcRenderer.send('version-info-requested'); ipcRenderer.send("version-info-requested");
}); });
}; };
/** /**
@ -447,117 +447,117 @@ lbry.getAppVersionInfo = function() {
* (If a real publish with the same name is found, the pending publish will be ignored and removed.) * (If a real publish with the same name is found, the pending publish will be ignored and removed.)
*/ */
lbry.file_list = function(params = {}) { lbry.file_list = function(params = {}) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
const { name, channel_name, outpoint } = params; const { name, channel_name, outpoint } = params;
/** /**
* If we're searching by outpoint, check first to see if there's a matching pending publish. * If we're searching by outpoint, check first to see if there's a matching pending publish.
* Pending publishes use their own faux outpoints that are always unique, so we don't need * Pending publishes use their own faux outpoints that are always unique, so we don't need
* to check if there's a real file. * to check if there's a real file.
*/ */
if (outpoint) { if (outpoint) {
const pendingPublish = getPendingPublish({ outpoint }); const pendingPublish = getPendingPublish({ outpoint });
if (pendingPublish) { if (pendingPublish) {
resolve([pendingPublishToDummyFileInfo(pendingPublish)]); resolve([pendingPublishToDummyFileInfo(pendingPublish)]);
return; return;
} }
} }
lbry.call( lbry.call(
'file_list', "file_list",
params, params,
fileInfos => { fileInfos => {
removePendingPublishIfNeeded({ name, channel_name, outpoint }); removePendingPublishIfNeeded({ name, channel_name, outpoint });
const dummyFileInfos = lbry const dummyFileInfos = lbry
.getPendingPublishes() .getPendingPublishes()
.map(pendingPublishToDummyFileInfo); .map(pendingPublishToDummyFileInfo);
resolve([...fileInfos, ...dummyFileInfos]); resolve([...fileInfos, ...dummyFileInfos]);
}, },
reject, reject,
reject reject
); );
}); });
}; };
lbry.claim_list_mine = function(params = {}) { lbry.claim_list_mine = function(params = {}) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
lbry.call( lbry.call(
'claim_list_mine', "claim_list_mine",
params, params,
claims => { claims => {
for (let { name, channel_name, txid, nout } of claims) { for (let { name, channel_name, txid, nout } of claims) {
removePendingPublishIfNeeded({ removePendingPublishIfNeeded({
name, name,
channel_name, channel_name,
outpoint: txid + ':' + nout outpoint: txid + ":" + nout,
}); });
} }
const dummyClaims = lbry const dummyClaims = lbry
.getPendingPublishes() .getPendingPublishes()
.map(pendingPublishToDummyClaim); .map(pendingPublishToDummyClaim);
resolve([...claims, ...dummyClaims]); resolve([...claims, ...dummyClaims]);
}, },
reject, reject,
reject reject
); );
}); });
}; };
const claimCacheKey = 'resolve_claim_cache'; const claimCacheKey = "resolve_claim_cache";
lbry._claimCache = getSession(claimCacheKey, {}); lbry._claimCache = getSession(claimCacheKey, {});
lbry._resolveXhrs = {}; lbry._resolveXhrs = {};
lbry.resolve = function(params = {}) { lbry.resolve = function(params = {}) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
if (!params.uri) { if (!params.uri) {
throw __('Resolve has hacked cache on top of it that requires a URI'); throw __("Resolve has hacked cache on top of it that requires a URI");
} }
if (params.uri && lbry._claimCache[params.uri] !== undefined) { if (params.uri && lbry._claimCache[params.uri] !== undefined) {
resolve(lbry._claimCache[params.uri]); resolve(lbry._claimCache[params.uri]);
} else { } else {
lbry._resolveXhrs[params.uri] = lbry.call( lbry._resolveXhrs[params.uri] = lbry.call(
'resolve', "resolve",
params, params,
function(data) { function(data) {
if (data !== undefined) { if (data !== undefined) {
lbry._claimCache[params.uri] = data; lbry._claimCache[params.uri] = data;
} }
setSession(claimCacheKey, lbry._claimCache); setSession(claimCacheKey, lbry._claimCache);
resolve(data); resolve(data);
}, },
reject reject
); );
} }
}); });
}; };
lbry.cancelResolve = function(params = {}) { lbry.cancelResolve = function(params = {}) {
const xhr = lbry._resolveXhrs[params.uri]; const xhr = lbry._resolveXhrs[params.uri];
if (xhr && xhr.readyState > 0 && xhr.readyState < 4) { if (xhr && xhr.readyState > 0 && xhr.readyState < 4) {
xhr.abort(); xhr.abort();
} }
}; };
lbry = new Proxy(lbry, { lbry = new Proxy(lbry, {
get: function(target, name) { get: function(target, name) {
if (name in target) { if (name in target) {
return target[name]; return target[name];
} }
return function(params = {}) { return function(params = {}) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
jsonrpc.call( jsonrpc.call(
lbry.daemonConnectionString, lbry.daemonConnectionString,
name, name,
params, params,
resolve, resolve,
reject, reject,
reject reject
); );
}); });
}; };
} },
}); });
export default lbry; export default lbry;