252 lines
8.8 KiB
TypeScript
252 lines
8.8 KiB
TypeScript
// Module ID: 11123
|
|
// Function ID: 11124
|
|
// Name: SpotifyUtils
|
|
// Dependencies: [5, 2006, 11124, 5593, 7792, 1086, 1103, 5596, 11125, 11126, 2]
|
|
// Exports: ensureSpotifyPlayable, ensureSpotifyPremium, getSpotifyMetadataFromActivity, isSpotifyPlayable, isSpotifyPremium
|
|
|
|
// Module 11123 (SpotifyUtils)
|
|
import Constants from "Constants" /* 1086 */;
|
|
import DurationsDefault from "Durations" /* 1103 */;
|
|
import PlatformsDefault from "Platforms" /* 5596 */;
|
|
import SpotifyActionCreators from "SpotifyActionCreators" /* 11125 */;
|
|
import UserActivityActionCreators from "UserActivityActionCreators" /* 11126 */;
|
|
import _asyncToGenerator from "_asyncToGenerator" /* 5 */;
|
|
import RunningGameStore from "RunningGameStore" /* 2006 */;
|
|
import SpotifyProtocolStore from "SpotifyProtocolStore" /* 11124 */;
|
|
import SpotifyStore from "SpotifyStore" /* 5593 */;
|
|
import SpotifyConstants from "SpotifyConstants" /* 7792 */;
|
|
import size from "module_2" /* 2 */;
|
|
|
|
let TRACK, closure_3, closure_4;
|
|
|
|
let c9;
|
|
let metroImportAll;
|
|
let metroImportDefault;
|
|
function asString(str) {
|
|
if (typeof str === "string") {
|
|
return str;
|
|
} else {
|
|
const _Error = Error;
|
|
const self = this;
|
|
const self2 = this;
|
|
const error = new Error("value is not a string");
|
|
throw error;
|
|
}
|
|
}
|
|
let value = function _getSpotifyMetadataFromActivity() {
|
|
const obj = _asyncToGenerator(async (arg0, type) => {
|
|
let closure_0 = arg0;
|
|
let c5 = 0;
|
|
let c6 = 0;
|
|
return (async function(arg0, value) {
|
|
let album_id;
|
|
let mapped;
|
|
let mapped1;
|
|
let obj4;
|
|
if (c6 === 2) {
|
|
c6 = 3;
|
|
throw new TypeError("Generator functions may not be called on executing generators");
|
|
} else if (tmp3 === 3) {
|
|
if (arg0 === 1) {
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
return { value, done: true };
|
|
} else {
|
|
return { value: "IconComponent", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
c6 = 2;
|
|
if (0 === c5) {
|
|
if (arg0 === 1) {
|
|
c6 = 3;
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
c6 = 3;
|
|
return { value, done: true };
|
|
} else {
|
|
closure_4 = tmp4;
|
|
closure_3 = tmp;
|
|
closure_0 = undefined;
|
|
type = undefined;
|
|
c5 = 1;
|
|
c6 = 1;
|
|
const obj5 = { value: obj4.getMetadata(closure_0, type), done: false };
|
|
obj4 = UserActivityActionCreators;
|
|
return obj5;
|
|
}
|
|
} else if (arg0 === 1) {
|
|
c6 = 3;
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
c6 = 3;
|
|
return { value, done: true };
|
|
} else {
|
|
closure_0 = value;
|
|
type = closure_0.type;
|
|
TRACK = type;
|
|
const tmp44 = closure_132_9;
|
|
const tmp45 = closure_132_12;
|
|
if (type == null) {
|
|
TRACK = closure_132_8.TRACK;
|
|
}
|
|
tmp45(TRACK);
|
|
type = tmp44(TRACK);
|
|
if (null === type) {
|
|
const _Error = Error;
|
|
const _HermesInternal = HermesInternal;
|
|
const self = this;
|
|
const self2 = this;
|
|
const error = new Error("invalid type " + closure_0.type);
|
|
throw error;
|
|
} else {
|
|
let context_uri;
|
|
if (typeof closure_0.context_uri === "string") {
|
|
context_uri = closure_0.context_uri;
|
|
}
|
|
value = { context_uri, album_id, artist_ids: mapped, type, button_urls: mapped1 };
|
|
album_id = closure_0.album_id;
|
|
closure_132_12(album_id);
|
|
const _Array = Array;
|
|
if (Array.isArray(closure_0.artist_ids)) {
|
|
const artist_ids = closure_0.artist_ids;
|
|
mapped = artist_ids.map(closure_132_12);
|
|
} else {
|
|
mapped = [];
|
|
}
|
|
const _Array2 = Array;
|
|
if (Array.isArray(closure_0.button_urls)) {
|
|
const button_urls = closure_0.button_urls;
|
|
mapped1 = button_urls.map(closure_132_12);
|
|
} else {
|
|
mapped1 = [];
|
|
}
|
|
c6 = 3;
|
|
return { value, done: true };
|
|
}
|
|
}
|
|
} catch (tmp38) {
|
|
c6 = 3;
|
|
throw tmp38;
|
|
}
|
|
}
|
|
})();
|
|
});
|
|
return obj(...arguments);
|
|
};
|
|
({ SPOTIFY_APP_PROTOCOL: metroImportDefault, SpotifyResourceTypes: metroImportAll, getSpotifyResourceType: c9 } = SpotifyConstants);
|
|
const PlatformTypes = Constants.PlatformTypes;
|
|
let closure_11 = 30 * DurationsDefault.Millis.SECOND;
|
|
const result = size.fileFinishedImporting("modules/spotify/SpotifyUtils.tsx");
|
|
|
|
export const isSpotifyPlayable = function isSpotifyPlayable(getActiveSocketAndDevice) {
|
|
const isProtocolRegisteredResult = null != getActiveSocketAndDevice.getActiveSocketAndDevice() || SpotifyProtocolStore.isProtocolRegistered();
|
|
return isProtocolRegisteredResult;
|
|
};
|
|
export const ensureSpotifyPlayable = function ensureSpotifyPlayable() {
|
|
let device;
|
|
let socket;
|
|
let obj = SpotifyStore;
|
|
const activeSocketAndDevice = SpotifyStore.getActiveSocketAndDevice();
|
|
if (null != activeSocketAndDevice) {
|
|
return Promise.resolve(activeSocketAndDevice);
|
|
} else if (SpotifyProtocolStore.isProtocolRegistered()) {
|
|
let playableComputerDevices = obj.getPlayableComputerDevices();
|
|
const isObservedAppRunning = RunningGameStore.isObservedAppRunning;
|
|
let obj2 = PlatformsDefault;
|
|
if (isObservedAppRunning(obj2.get(PlatformTypes.SPOTIFY).name)) {
|
|
if (playableComputerDevices.length > 0) {
|
|
({ socket, device } = playableComputerDevices[0]);
|
|
const obj3 = playableComputerDevices(11125);
|
|
obj3.setActiveDevice(socket.accountId, device.id);
|
|
const obj4 = { socket, device };
|
|
return Promise.resolve(obj4);
|
|
}
|
|
}
|
|
const self3 = this;
|
|
const self4 = this;
|
|
const promise = new Promise((arg0, arg1) => {
|
|
let closure_2;
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
function onSpotifyStoreChange() {
|
|
playableComputerDevices = SpotifyStore.getPlayableComputerDevices();
|
|
function _loop(socket, device) {
|
|
if (null == closure_1_0.find((device) => device.device.id === device.id)) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(closure_2);
|
|
closure_2_6.removeChangeListener(closure_3);
|
|
const _setImmediate = setImmediate;
|
|
setImmediate(() => {
|
|
const obj = playableComputerDevices(dependencyMap[8]);
|
|
obj.setActiveDevice(socket.accountId, device.id);
|
|
const obj2 = { socket, device };
|
|
closure_2_0(obj2);
|
|
});
|
|
}
|
|
}
|
|
const iter = playableComputerDevices[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let _loopResult = _loop(nextResult.socket, nextResult.device);
|
|
continue;
|
|
}
|
|
}
|
|
const timeout = setTimeout(() => {
|
|
SpotifyStore.removeChangeListener(onSpotifyStoreChange);
|
|
const error = new Error("timeout launching spotify");
|
|
closure_1(error);
|
|
}, closure_1_11);
|
|
SpotifyStore.addChangeListener(onSpotifyStoreChange);
|
|
window.open("" + closure_1_7 + ":");
|
|
});
|
|
return promise;
|
|
} else {
|
|
const tmp2 = globalThis;
|
|
const _Error = Error;
|
|
const self = this;
|
|
const self2 = this;
|
|
let error = new Error("protocol is not registered");
|
|
return reject(error);
|
|
}
|
|
};
|
|
export const isSpotifyPremium = function isSpotifyPremium() {
|
|
const activeSocketAndDevice = SpotifyStore.getActiveSocketAndDevice();
|
|
let isPremium = null;
|
|
if (null != activeSocketAndDevice) {
|
|
isPremium = activeSocketAndDevice.socket.isPremium;
|
|
}
|
|
return isPremium;
|
|
};
|
|
export const ensureSpotifyPremium = function ensureSpotifyPremium() {
|
|
const activeSocketAndDevice = SpotifyStore.getActiveSocketAndDevice();
|
|
if (null == activeSocketAndDevice) {
|
|
let _Error = Error;
|
|
let self = this;
|
|
let self2 = this;
|
|
let error = new Error("no active profile");
|
|
return reject(error);
|
|
} else {
|
|
let resolved;
|
|
const socket = activeSocketAndDevice.socket;
|
|
if (socket.isPremium) {
|
|
resolved = Promise.resolve();
|
|
} else {
|
|
const obj = SpotifyActionCreators;
|
|
const profile = obj.getProfile(socket.accountId, socket.accessToken);
|
|
resolved = profile.then(function() {
|
|
if (!socket.isPremium) {
|
|
const _Error = Error;
|
|
const self = this;
|
|
const self2 = this;
|
|
const error = new Error("spotify account is not premium");
|
|
return reject(error);
|
|
}
|
|
});
|
|
}
|
|
return resolved;
|
|
}
|
|
};
|
|
export const getSpotifyMetadataFromActivity = function getSpotifyMetadataFromActivity() {
|
|
return obj(...arguments);
|
|
};
|