move types to lib/types.ts

Author: oyejorge

lib/sifter.ts

@@ -18,72 +18,21 @@
 import { scoreValue, getAttr, getAttrNesting, escape_regex, propToArray, iterate, cmp } from './utils.ts';
 // @ts-ignore TS2691 "An import path cannot end with a '.ts' extension"
 import { diacriticRegexPoints, asciifold } from './diacritics.ts';
-
-
-type TField = {
-	field: string,
-	weight: number,
-}
-
-type TSort = {
-	field: string,
-	direction?: string,
-}
-
-type TOptions = {
- 	fields: TField[],
- 	sort: TSort[],
- 	score?: ()=>any,
- 	filter?: boolean,
- 	limit?: number,
- 	sort_empty?: TSort[],
- 	nesting?: boolean,
-	respect_word_boundaries?: boolean,
-	conjunction?: string,
-}
-
-type TToken = {
-	string:string,
-	regex:RegExp|null,
-	field:string|null,
-}
-
-type TWeights = {[key:string]:number}
-
-type TPrepareObj = {
-	options: TOptions,
-	query: string,
-	tokens: TToken[],
-	total: number,
-	items: TResultItem[],
-	weights: TWeights,
-	getAttrFn: (data:any,field:string)=>any,
-
-}
-
-type TSettings = {
-	diacritics:boolean
-}
-
-type TResultItem = {
-	score: number,
-	id: number|string,
-}
-
-
+// @ts-ignore TS2691 "An import path cannot end with a '.ts' extension"
+import * as T from 'types.ts';
 
 export default class Sifter{
 
 	public items; // []|{};
-	public settings: TSettings;
+	public settings: T.Settings;
 
 	/**
 	 * Textually searches arrays and hashes of objects
 	 * by property (or multiple properties). Designed
 	 * specifically for autocomplete.
 	 *
 	 */
-	constructor(items:any, settings:TSettings) {
+	constructor(items:any, settings:T.Settings) {
 		this.items = items;
 		this.settings = settings || {diacritics: true};
 	};
@@ -93,10 +42,10 @@ export default class Sifter{
 	 * regexps to be used to match results.
 	 *
 	 */
-	tokenize(query:string, respect_word_boundaries?:boolean, weights?:TWeights ):TToken[] {
+	tokenize(query:string, respect_word_boundaries?:boolean, weights?:T.Weights ):T.Token[] {
 		if (!query || !query.length) return [];
 
-		const tokens:TToken[]	= [];
+		const tokens:T.Token[]	= [];
 		const words				= query.split(/\s+/);
 		var field_regex:RegExp;
 
@@ -142,12 +91,12 @@ export default class Sifter{
 	 *
 	 * @returns {function}
 	 */
-	getScoreFunction(query:string, options:TOptions ){
+	getScoreFunction(query:string, options:T.Options ){
 		var search = this.prepareSearch(query, options);
 		return this._getScoreFunction(search);
 	}
 
-	_getScoreFunction(search:TPrepareObj ){
+	_getScoreFunction(search:T.PrepareObj ){
 		const tokens		= search.tokens,
 		token_count			= tokens.length;
 
@@ -169,21 +118,18 @@ export default class Sifter{
 		 * Calculates the score of an object
 		 * against the search query.
 		 *
-		 * @param {TToken} token
-		 * @param {object} data
-		 * @return {number}
 		 */
 		const scoreObject = (function() {
 
 
 			if (field_count === 1) {
-				return function(token:TToken, data:{}) {
+				return function(token:T.Token, data:{}) {
 					const field = fields[0].field;
 					return scoreValue(getAttrFn(data, field), token, weights[field]);
 				};
 			}
 
-			return function(token:TToken, data:{}) {
+			return function(token:T.Token, data:{}) {
 				var sum = 0;
 
 				// is the token specific to a field?
@@ -228,7 +174,7 @@ export default class Sifter{
 		} else {
 			return function(data:{}) {
 				var sum = 0;
-				iterate(tokens,(token:TToken)=>{
+				iterate(tokens,(token:T.Token)=>{
 					sum += scoreObject(token, data);
 				});
 				return sum / token_count;
@@ -243,18 +189,18 @@ export default class Sifter{
 	 *
 	 * @return function(a,b)
 	 */
-	getSortFunction(query:string, options:TOptions) {
+	getSortFunction(query:string, options:T.Options) {
 		var search  = this.prepareSearch(query, options);
 		return this._getSortFunction(search);
 	}
 
-	_getSortFunction(search:TPrepareObj){
+	_getSortFunction(search:T.PrepareObj){
 		var i, n, implicit_score;
 
 		const self	= this,
 		options		= search.options,
 		sort		= (!search.query && options.sort_empty) ? options.sort_empty : options.sort,
-		sort_flds:TSort[]		= [],
+		sort_flds:T.Sort[]		= [],
 		multipliers:number[]	= [];
 
 
@@ -263,7 +209,7 @@ export default class Sifter{
 		 * from a search result item.
 		 *
 		 */
-		const get_field = function(name:string, result:TResultItem):string|number {
+		const get_field = function(name:string, result:T.ResultItem):string|number {
 			if (name === '$score') return result.score;
 			return search.getAttrFn(self.items[result.id], name);
 		};
@@ -310,14 +256,14 @@ export default class Sifter{
 		} else if (sort_flds_count === 1) {
 			const sort_fld = sort_flds[0].field;
 			const multiplier = multipliers[0];
-			return function(a:TResultItem, b:TResultItem) {
+			return function(a:T.ResultItem, b:T.ResultItem) {
 				return multiplier * cmp(
 					get_field(sort_fld, a),
 					get_field(sort_fld, b)
 				);
 			};
 		} else {
-			return function(a:TResultItem, b:TResultItem) {
+			return function(a:T.ResultItem, b:T.ResultItem) {
 				var i, result, field;
 				for (i = 0; i < sort_flds_count; i++) {
 					field = sort_flds[i].field;
@@ -338,8 +284,8 @@ export default class Sifter{
 	 * with results.
 	 *
 	 */
-	prepareSearch(query:string, optsUser:TOptions):TPrepareObj {
-		const weights:TWeights = {};
+	prepareSearch(query:string, optsUser:T.Options):T.PrepareObj {
+		const weights:T.Weights = {};
 		var options		= Object.assign({},optsUser);
 
 		propToArray(options,'sort');
@@ -348,8 +294,8 @@ export default class Sifter{
 		// convert fields to new format
 		if( options.fields ){
 			propToArray(options,'fields');
-			const fields:TField[] = [];
-			options.fields.forEach((field:string|TField) => {
+			const fields:T.Field[] = [];
+			options.fields.forEach((field:string|T.Field) => {
 				if( typeof field == 'string' ){
 					field = {field:field,weight:1};
 				}
@@ -376,8 +322,8 @@ export default class Sifter{
 	 * Searches through all items and returns a sorted array of matches.
 	 *
 	 */
-	search(query:string, options:TOptions) : TPrepareObj {
-		var self = this, score, search:TPrepareObj;
+	search(query:string, options:T.Options) : T.PrepareObj {
+		var self = this, score, search:T.PrepareObj;
 
 		search  = this.prepareSearch(query, options);
 		options = search.options;
@@ -388,14 +334,14 @@ export default class Sifter{
 
 		// perform search and sort
 		if (query.length) {
-			iterate(self.items, (item:TResultItem, id:string|number) => {
+			iterate(self.items, (item:T.ResultItem, id:string|number) => {
 				score = fn_score(item);
 				if (options.filter === false || score > 0) {
 					search.items.push({'score': score, 'id': id});
 				}
 			});
 		} else {
-			iterate(self.items, (item:TResultItem, id:string|number) => {
+			iterate(self.items, (item:T.ResultItem, id:string|number) => {
 				search.items.push({'score': 1, 'id': id});
 			});
 		}

lib/types.ts

@@ -0,0 +1,50 @@
+
+export type Field = {
+	field: string,
+	weight: number,
+}
+
+export type Sort = {
+	field: string,
+	direction?: string,
+}
+
+export type Options = {
+ 	fields: Field[],
+ 	sort: Sort[],
+ 	score?: ()=>any,
+ 	filter?: boolean,
+ 	limit?: number,
+ 	sort_empty?: Sort[],
+ 	nesting?: boolean,
+	respect_word_boundaries?: boolean,
+	conjunction?: string,
+}
+
+export type Token = {
+	string:string,
+	regex:RegExp|null,
+	field:string|null,
+}
+
+export type Weights = {[key:string]:number}
+
+export type PrepareObj = {
+	options: Options,
+	query: string,
+	tokens: Token[],
+	total: number,
+	items: ResultItem[],
+	weights: Weights,
+	getAttrFn: (data:any,field:string)=>any,
+
+}
+
+export type Settings = {
+	diacritics:boolean
+}
+
+export type ResultItem = {
+	score: number,
+	id: number|string,
+}

lib/utils.ts

@@ -3,7 +3,7 @@
 import { asciifold } from './diacritics.ts';
 
 // @ts-ignore TS2691 "An import path cannot end with a '.ts' extension"
-import { TToken } from './sifter.ts';
+import * as T from './types.ts';
 
 
 /**
@@ -35,7 +35,7 @@ export function getAttrNesting(obj:{[key:string]:any}, name:string ) {
  * given value is against a search token.
  *
  */
-export function scoreValue(value:string, token:TToken, weight:number ):number {
+export function scoreValue(value:string, token:T.Token, weight:number ):number {
 	var score, pos;
 
 	if (!value) return 0;