Use new completion use-case on current use-case (aliased)

2 files changed, 20 insertions, 111 deletions

diff --git a/src/background/usecases/CompletionsUseCase.ts b/src/background/usecases/CompletionsUseCase.ts
index 9874644..b75b635 100644
--- a/src/background/usecases/CompletionsUseCase.ts
+++ b/src/background/usecases/CompletionsUseCase.ts
@@ -2,15 +2,12 @@ import { injectable, inject } from 'tsyringe';
 import CompletionGroup from '../domains/CompletionGroup';
 import CommandDocs from '../domains/CommandDocs';
 import CompletionsRepository from '../repositories/CompletionsRepository';
-import * as filters from './filters';
 import CachedSettingRepository from '../repositories/CachedSettingRepository';
 import TabPresenter from '../presenters/TabPresenter';
 import Properties from '../../shared/settings/Properties';
-
-const COMPLETION_ITEM_LIMIT = 10;
+import CompletionUseCase from "../completion/CompletionUseCase";
 
 type Tab = browser.tabs.Tab;
-type HistoryItem = browser.history.HistoryItem;
 
 @injectable()
 export default class CompletionsUseCase {
@@ -18,6 +15,7 @@ export default class CompletionsUseCase {
     private tabPresenter: TabPresenter,
     private completionsRepository: CompletionsRepository,
     @inject("CachedSettingRepository") private cachedSettingRepository: CachedSettingRepository,
+    private completionUseCase: CompletionUseCase
   ) {
   }
 
@@ -179,42 +177,29 @@ export default class CompletionsUseCase {
     return [{ name: 'Buffers', items }];
   }
 
-  async querySearchEngineItems(name: string, keywords: string) {
-    const settings = await this.cachedSettingRepository.get();
-    const engines = Object.keys(settings.search.engines)
-      .filter(key => key.startsWith(keywords));
-    return engines.map(key => ({
-      caption: key,
-      content: name + ' ' + key,
+  async querySearchEngineItems(name: string, query: string) {
+    const engines = await this.completionUseCase.requestSearchEngines(query);
+    return engines.map(item => ({
+      caption: item,
+      content: name + ' ' + item,
     }));
   }
 
-  async queryHistoryItems(name: string, keywords: string) {
-    let histories = await this.completionsRepository.queryHistories(keywords);
-    histories = [histories]
-      .map(filters.filterBlankTitle)
-      .map(filters.filterHttp)
-      .map(filters.filterByTailingSlash)
-      .map(pages => filters.filterByPathname(pages, COMPLETION_ITEM_LIMIT))
-      .map(pages => filters.filterByOrigin(pages, COMPLETION_ITEM_LIMIT))[0]
-      .sort((x: HistoryItem, y: HistoryItem): number => {
-        return Number(y.visitCount) - Number(x.visitCount);
-      })
-      .slice(0, COMPLETION_ITEM_LIMIT);
-    return histories.map(page => ({
-      caption: page.title,
-      content: name + ' ' + page.url,
-      url: page.url
+  async queryHistoryItems(name: string, query: string) {
+    const items = await this.completionUseCase.requestHistory(query);
+    return items.map(item => ({
+      caption: item.title,
+      content: name + ' ' + item.url,
+      url: item.url
     }));
   }
 
-  async queryBookmarkItems(name: string, keywords: string) {
-    const bookmarks = await this.completionsRepository.queryBookmarks(keywords);
-    return bookmarks.slice(0, COMPLETION_ITEM_LIMIT)
-      .map(page => ({
-        caption: page.title,
-        content: name + ' ' + page.url,
-        url: page.url
-      }));
+  async queryBookmarkItems(name: string, query: string) {
+    const items = await this.completionUseCase.requestHistory(query);
+    return items.map(item => ({
+      caption: item.title,
+      content: name + ' ' + item.url,
+      url: item.url
+    }));
   }
 }
diff --git a/src/background/usecases/filters.ts b/src/background/usecases/filters.ts
deleted file mode 100644
index 98957a7..0000000
--- a/src/background/usecases/filters.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-type Item = browser.history.HistoryItem;
-
-const filterHttp = (items: Item[]): Item[] => {
-  const httpsHosts = items.map(x => new URL(x.url as string))
-    .filter(x => x.protocol === 'https:')
-    .map(x => x.host);
-  const hostsSet = new Set(httpsHosts);
-
-  return items.filter((item: Item) => {
-    const url = new URL(item.url as string);
-    return url.protocol === 'https:' || !hostsSet.has(url.host);
-  });
-};
-
-const filterBlankTitle = (items: Item[]): Item[] => {
-  return items.filter(item => item.title && item.title !== '');
-};
-
-const filterByTailingSlash = (items: Item[]): Item[] => {
-  const urls = items.map(item => new URL(item.url as string));
-  const simplePaths = urls
-    .filter(url => url.hash === '' && url.search === '')
-    .map(url => url.origin + url.pathname);
-  const pathsSet = new Set(simplePaths);
-
-  return items.filter((item) => {
-    const url = new URL(item.url as string);
-    if (url.hash !== '' || url.search !== '' ||
-      url.pathname.slice(-1) !== '/') {
-      return true;
-    }
-    return !pathsSet.has(url.origin + url.pathname.slice(0, -1));
-  });
-};
-
-const filterByPathname = (items: Item[], min: number): Item[] => {
-  const hash: {[key: string]: Item} = {};
-  for (const item of items) {
-    const url = new URL(item.url as string);
-    const pathname = url.origin + url.pathname;
-    if (!hash[pathname]) {
-      hash[pathname] = item;
-    } else if ((hash[pathname].url as string).length >
-      (item.url as string).length) {
-      hash[pathname] = item;
-    }
-  }
-  const filtered = Object.values(hash);
-  if (filtered.length < min) {
-    return items;
-  }
-  return filtered;
-};
-
-const filterByOrigin = (items: Item[], min: number): Item[] => {
-  const hash: {[key: string]: Item} = {};
-  for (const item of items) {
-    const origin = new URL(item.url as string).origin;
-    if (!hash[origin]) {
-      hash[origin] = item;
-    } else if ((hash[origin].url as string).length >
-      (item.url as string).length) {
-      hash[origin] = item;
-    }
-  }
-  const filtered = Object.values(hash);
-  if (filtered.length < min) {
-    return items;
-  }
-  return filtered;
-};
-
-export {
-  filterHttp, filterBlankTitle, filterByTailingSlash,
-  filterByPathname, filterByOrigin
-};