Add tag searching

source/core/Vault.ts

@@ -173,8 +173,26 @@ export class Vault extends EventEmitter {
  return findEntriesByProperty(this._entries, property, value);
  }
 
- findEntriesByTag(tag: string): Array<Entry> {
+ /**
+ * Find entries by a certain tag
+ * @param tag The case-insensitive tag name
+ * @param exact Whether to match exact tag names or use partial
+ * matching. Default is true (exact).
+ * @returns An array of entries
+ */
+ findEntriesByTag(tag: string, exact: boolean = true): Array<Entry> {
  const tagLower = tag.toLowerCase();
+ if (!exact) {
+ const entryIDs = new Set<string>();
+ for (const [currentTag, currentIDs] of this._tagMap.entries()) {
+ if (currentTag.toLowerCase().indexOf(tagLower) === 0) {
+ for (const id of currentIDs) {
+ entryIDs.add(id);
+ }
+ }
+ }
+ return [...entryIDs].map((id) => this.findEntryByID(id));
+ }
  const entryIDs = this._tagMap.has(tagLower) ? this._tagMap.get(tagLower) : [];
  return entryIDs.map((id) => this.findEntryByID(id));
  }

source/facades/entry.ts

@@ -197,6 +197,22 @@ export function createEntryFromFacade(group: Group, facade: EntryFacade): Entry
  return entry;
 }
 
+/**
+ * Convert an array of entry facade fields to a
+ * key-value object with only attributes
+ * @param facadeFields Array of fields
+ * @memberof module:Buttercup
+ */
+export function fieldsToAttributes(facadeFields: Array<EntryFacadeField>): {
+ [key: string]: string;
+} {
+ return facadeFields.reduce((output, field) => {
+ if (field.propertyType !== EntryPropertyType.Attribute) return output;
+ output[field.property] = field.value;
+ return output;
+ }, {});
+}
+
 /**
  * Convert an array of entry facade fields to a
  * key-value object with only properties
@@ -207,7 +223,7 @@ export function fieldsToProperties(facadeFields: Array<EntryFacadeField>): {
  [key: string]: string;
 } {
  return facadeFields.reduce((output, field) => {
- if (field.propertyType !== "property") return output;
+ if (field.propertyType !== EntryPropertyType.Property) return output;
  output[field.property] = field.value;
  return output;
  }, {});

source/search/BaseSearch.ts

@@ -3,6 +3,7 @@ import { StorageInterface } from "../storage/StorageInterface.js";
 import { buildSearcher } from "./searcher.js";
 import { Vault } from "../core/Vault.js";
 import { EntryID, EntryType, GroupID, VaultFacade, VaultID } from "../types.js";
+import { extractTagsFromSearchTerm } from "./tags.js";
 
 interface DomainScores {
  [domain: string]: number;
@@ -22,10 +23,11 @@ export interface SearcherFactory {
 }
 
 export interface SearchResult {
- id: EntryID;
+ entryType: EntryType;
  groupID: GroupID;
+ id: EntryID;
  properties: { [property: string]: string };
- entryType: EntryType;
+ tags: Array<string>;
  urls: Array<string>;
  vaultID: VaultID;
 }
@@ -137,6 +139,17 @@ export class BaseSearch {
  if (!this._fuse) {
  throw new Error("Searching interface not prepared");
  }
+ const { tags, term: searchTerm } = extractTagsFromSearchTerm(term);
+ if (tags.length > 0) {
+ // Instantiate new searcher based on a subset of entries
+ const subset = this._entries.filter((entry) =>
+ entry.tags.some((entryTag) => tags.includes(entryTag))
+ );
+ this._fuse = this._searcherFactory(subset);
+ } else {
+ // Reset instance
+ this._fuse = this._searcherFactory(this._entries);
+ }
  this._results = this._fuse.search(term).map((result) => result.item);
  return this._results;
  }

source/search/VaultEntrySearch.ts

@@ -25,13 +25,14 @@ async function extractEntries(
  const properties = entry.getProperties();
  const urls = getEntryURLs(properties, EntryURLType.General);
  return {
+ domainScores: vaultScore[entry.id] || {},
+ entryType: entry.getType(),
+ groupID: entry.getGroup().id,
  id: entry.id,
  properties,
- entryType: entry.getType(),
+ tags: entry.getTags(),
  urls,
- groupID: entry.getGroup().id,
- vaultID: vault.id,
- domainScores: vaultScore[entry.id] || {}
+ vaultID: vault.id
  };
  });
 }

source/search/VaultFacadeEntrySearch.ts

@@ -1,8 +1,10 @@
+import { Entry } from "../core/Entry.js";
 import { BaseSearch, ProcessedSearchEntry, SearcherFactory } from "./BaseSearch.js";
 import { EntryURLType, getEntryURLs } from "../tools/entry.js";
-import { fieldsToProperties } from "../facades/entry.js";
+import { fieldsToAttributes, fieldsToProperties } from "../facades/entry.js";
 import { StorageInterface } from "../storage/StorageInterface.js";
 import { EntryFacade, VaultFacade } from "../types.js";
+import { isValidTag } from "../tools/tag.js";
 
 async function extractEntries(
  facade: VaultFacade,
@@ -20,16 +22,23 @@ async function extractEntries(
  // Get entries
  return facade.entries.reduce((entries: Array<ProcessedSearchEntry>, nextEntry: EntryFacade) => {
  // @todo in trash
+ const attributes = fieldsToAttributes(nextEntry.fields);
+ const tags = attributes[Entry.Attributes.Tags]
+ ? attributes[Entry.Attributes.Tags].split(",").reduce((output, tag) => {
+ return isValidTag(tag) ? [...output, tag] : output;
+ }, [])
+ : [];
  const properties = fieldsToProperties(nextEntry.fields);
  const urls = getEntryURLs(properties, EntryURLType.General);
  entries.push({
+ domainScores: vaultScore[nextEntry.id] || {},
+ entryType: nextEntry.type,
+ groupID: nextEntry.parentID,
  id: nextEntry.id,
  properties,
- entryType: nextEntry.type,
+ tags,
  urls,
- groupID: nextEntry.parentID,
- vaultID: facade.id,
- domainScores: vaultScore[nextEntry.id] || {}
+ vaultID: facade.id
  });
  return entries;
  }, []);

source/search/tags.ts

@@ -0,0 +1,20 @@
+export function extractTagsFromSearchTerm(term: string): {
+ tags: Array<string>;
+ term: string;
+} {
+ const searchItems: Array<string> = [];
+ const tags = new Set<string>();
+ const parts = term.split(/\s+/g);
+ for (const part of parts) {
+ if (/^#.+/.test(part)) {
+ const raw = part.replace(/^#/, "");
+ tags.add(raw.toLowerCase());
+ } else if (part.length > 0) {
+ searchItems.push(part);
+ }
+ }
+ return {
+ tags: [...tags],
+ term: searchItems.join(" ").trim()
+ };
+}