}).views((self) => {
return {
getSearch(id) {
return resolveIdentifier(SearchStore, self, id);
},
};
});
}).views((self) => {
return {
get tracker() {
return resolveIdentifier(TrackerStore, self, self.id);
},
get query() {
return getParentOfType(self, SearchStore).query;
},
get queryHighlightMap() {
return getParentOfType(self, SearchStore).queryHighlightMap;
},
get queryRateScheme() {
return getParentOfType(self, SearchStore).queryRateScheme;
},
};
});
return self.ids.map(id => resolveIdentifier(extensionModel, self, id)).filter(a => a);
}).views(self => {
const handleInstalledListener = extension => {
self.setExtension(extension);
};
const handleUninstalledListener = id => {
self.removeExtension(id);
};
const handleEnabled = extension => {
self.setExtension(extension);
};
const handleDisabled = extension => {
self.setExtension(extension);
};
const handleStorageChanged = (changes, areaName) => {
switch (areaName) {
case 'sync': {
if (changes.list) {
self.syncUserGroups(changes.list.newValue);
}
break;
}
}
};
return {
getGroupById(id) {
return resolveIdentifier(groupModel, self, id);
},
getUserGroups() {
return self.groups.filter(group => {
return !group.computed;
});
},
getExtensionsWithoutGroup() {
const groupExtensionIds = [];
self.getUserGroups().forEach(group => {
groupExtensionIds.push(...group.getIds());
});
return Array.from(self.extensions.values()).filter(extensoin => groupExtensionIds.indexOf(extensoin.id) === -1);
},
getExtensionsByType(type) {
const extensions = self.getExtensionsWithoutGroup();
if (type === 'unknown') {
return extensions.filter(extension => extensionTypes.indexOf(extension.type) === -1);
} else {
return extensions.filter(extension => extension.type === type);
}
},
saveGroups() {
return oneLimit(() => {
const userGroups = self.getUserGroups();
const list = JSON.parse(JSON.stringify(userGroups));
list.forEach(group => {
group.isLoading = undefined;
group.computed = undefined;
});
return promisifyApi('chrome.storage.sync.set')({list: list});
});
},
afterCreate() {
self.assign({isLoading: true});
const computedGroups = [...extensionTypes, 'unknown'].map(type => {
return groupModel.create({
computed: type,
name: chrome.i18n.getMessage(toCameCase(type) + 'Type') || chrome.i18n.getMessage('unknownType'),
});
});
self.unshiftGroup(...computedGroups);
return Promise.all([
promisifyApi('chrome.storage.sync.get')({list: []}).then(storage => {
chrome.storage.onChanged.addListener(handleStorageChanged);
self.unshiftGroup(...storage.list);
}),
promisifyApi('chrome.management.getAll')().then(result => {
chrome.management.onInstalled.addListener(handleInstalledListener);
chrome.management.onUninstalled.addListener(handleUninstalledListener);
chrome.management.onEnabled.addListener(handleEnabled);
chrome.management.onDisabled.addListener(handleDisabled);
result.forEach(extension => {
if (extension.id !== chrome.runtime.id) {
try {
self.setExtension(extension);
} catch (err) {
debug('setExtension error', extension, err);
}
}
});
})
]).then(() => {
self.groups.forEach(group => {
group.removeIfEmpty();
});
}).catch(err => {
debug('Loading error', err);
}).then(() => {
self.assign({isLoading: false});
});
}
};
});
}).views(self => {
const storageChangeListener = (changes, namespace) => {
if (self.state !== 'done') return;
if (namespace === 'sync') {
const change = changes.explorerSections;
if (change) {
const newValue = change.newValue || [];
const oldValue = reOrderStoreItems(self.sections, newValue, 'id');
self.setSections(oldValue);
const diff = mobxCompare(self.sections, newValue).filter((patch) => {
if (/^\/\d+\/(state|authRequired|items|commands)(\/.*|$)/.test(patch.path)) {
return false;
}
return true;
});
self.patchSections(diff);
}
}
if (namespace === 'local') {
const change = changes.explorerModules;
if (change) {
const newValue = change.newValue || {};
const diff = mobxCompare(self.modules, newValue);
self.patchModules(diff);
}
}
};
return {
getSectionsSnapshot() {
return self.sections.map(section => section.getSnapshot());
},
getModulesSnapshot() {
return self.modules.toJSON();
},
saveSections() {
return limitOne(() => {
const sections = self.getSectionsSnapshot();
return storageSet({explorerSections: sections}, 'sync');
});
},
moveSection(index, prevIndex, nextIndex) {
const sections = self.sections.slice(0);
const item = sections[index];
const prevItem = sections[prevIndex];
const nextItem = sections[nextIndex];
sections.splice(index, 1);
if (prevItem) {
const pos = sections.indexOf(prevItem);
if (pos !== -1) {
sections.splice(pos + 1, 0, item);
}
} else
if (nextItem) {
const pos = sections.indexOf(nextItem);
if (pos !== -1) {
sections.splice(pos, 0, item);
}
} else {
sections.push(item);
}
self.setSections(sections);
},
get favoritesSection() {
return resolveIdentifier(ExplorerFavoritesSectionStore, self, 'favorites');
},
getSectionById(id) {
if (id === 'favorites') {
return self.favoritesSection;
} else {
return resolveIdentifier(ExplorerSectionStore, self, id);
}
},
afterCreate() {
chrome.storage.onChanged.addListener(storageChangeListener);
},
beforeDestroy() {
chrome.storage.onChanged.removeListener(storageChangeListener);
},
};
});
}).views((self) => {
return {
getFileById(name) {
return resolveIdentifier(FileStore, self, name);
},
getFileIndexById(name) {
const file = self.getFileById(name);
if (file) {
return self.files.indexOf(file);
}
return null;
},
get torrent() {
return resolveIdentifier(TorrentStore, self, self.id);
},
get filteredFiles() {
if (self.filter) {
const filter = self.filter + '/';
const filterLen = filter.length;
return self.files.filter((file) => {
return file.normalizedName.substr(0, filterLen) === filter;
});
} else {
return self.files;
}
},
get sortedFiles() {
/**@type RootStore*/const rootStore = getRoot(self);
const {by, direction} = rootStore.config.filesSort;
const files = self.filteredFiles.slice(0);
const byColumn = byColumnMap[by] || by;
const upDown = [-1, 1];
if (direction === 1) {
upDown.reverse();
}
files.sort((aa, bb) => {
const a = aa[byColumn];
const b = bb[byColumn];
const [up, down] = upDown;
if (a === b) {
return 0;
}
if (a > b) {
return up;
}
return down;
});
return files;
},
get _sortedIds() {
return self.sortedFiles.map(file => file.name);
},
get selectedIndexes() {
return self.selectedIds.map(name => self.getFileIndexById(name));
},
get filterLevel() {
const filter = self.filter;
return !filter ? 0 : filter.split(/[\\/]/).length;
},
get joinedDirectory() {
const directory = self.torrent.directory;
if (directory) {
if (self.directory) {
const sep = /\//.test(directory) ? '/' : '\\';
return directory + sep + self.directory;
} else {
return directory;
}
}
return '';
},
afterCreate() {
self.startSortedIdsWatcher();
},
beforeDestroy() {
self.stopSortedIdsWatcher();
if (self.removeSelectOnHide) {
/**@type RootStore*/const rootStore = getRoot(self);
rootStore.torrentList.removeSelectedId(self.id);
}
}
};
});