@wener/common 1.0.3 → 1.0.4

package/src/search/AdvanceSearch.test.ts

@@ -2,155 +2,148 @@ import { describe, expect, it } from 'vitest';
 import { AdvanceSearch } from './AdvanceSearch';
 
 describe('AdvanceSearch', () => {
-  it('should parse', () => {
-    for (const input of [
-      //
-      '-a',
-      'a',
-      'a b',
-      'a -b',
-      'a-b',
-      'a"b',
-      'a&b',
-      'NOT a',
-      'NOT -a',
-      'HELLO -WORLD',
-      '(a)',
-      '( a OR B )',
-      'A OR B',
-      'a:[1,2]',
-      'a:*..1',
-      'a:ok a:=1 a:>1 a:<1 a:>=1 a:<=1 a:!=1 a:1..2 a:*..1 a:1..* a:[1,2] a:(1,2) a:[1,2) a:(1,2]',
-      'NOT (A B) AND (a:ok AND size:>1)',
-      'NOT -a',
-      'NOT (NOT -a)',
-      'owner:@me owner:=@me owner:!=@me',
-      '@AI:"Where is my car"',
-      '/**/ a',
-      '/* Hint */ a',
-      '/* a */ a /* b */',
-    ]) {
-      let out = AdvanceSearch.parse(input);
-      let formated = AdvanceSearch.format(out);
-      expect(formated, `reformat`).toMatchSnapshot();
-      let optimized = AdvanceSearch.format(AdvanceSearch.optimize(out));
-      expect(optimized, `optimized`).toMatchSnapshot();
-      expect(out, `parsed`).toMatchSnapshot();
-      expect(AdvanceSearch.parse(formated), `reformat match original`).toMatchObject(out);
-    }
-  });
-  it('should parse as expected', () => {
-    type Case = [string | null | undefined, AdvanceSearch.Expr[]];
+	it('should parse', () => {
+		for (const input of [
+			//
+			'-a',
+			'a',
+			'a b',
+			'a -b',
+			'a-b',
+			'a"b',
+			'a&b',
+			'NOT a',
+			'NOT -a',
+			'HELLO -WORLD',
+			'(a)',
+			'( a OR B )',
+			'A OR B',
+			'a:[1,2]',
+			'a:*..1',
+			'a:ok a:=1 a:>1 a:<1 a:>=1 a:<=1 a:!=1 a:1..2 a:*..1 a:1..* a:[1,2] a:(1,2) a:[1,2) a:(1,2]',
+			'NOT (A B) AND (a:ok AND size:>1)',
+			'NOT -a',
+			'NOT (NOT -a)',
+			'owner:@me owner:=@me owner:!=@me',
+			'@AI:"Where is my car"',
+			'/**/ a',
+			'/* Hint */ a',
+			'/* a */ a /* b */',
+		]) {
+			let out = AdvanceSearch.parse(input);
+			let formated = AdvanceSearch.format(out);
+			expect(formated, `reformat`).toMatchSnapshot();
+			let optimized = AdvanceSearch.format(AdvanceSearch.optimize(out));
+			expect(optimized, `optimized`).toMatchSnapshot();
+			expect(out, `parsed`).toMatchSnapshot();
+			expect(AdvanceSearch.parse(formated), `reformat match original`).toMatchObject(out);
+		}
+	});
+	it('should parse as expected', () => {
+		type Case = [string | null | undefined, AdvanceSearch.Expr[]];
 
-    const cases: Case[] = [
-      [null, []],
-      [undefined, []],
-      ['', []],
-      // fast path
-      ['a', [{ type: 'keyword', value: 'a' }]],
-      ['a-b', [{ type: 'keyword', value: 'a-b' }]],
-      ['a"b', [{ type: 'keyword', value: 'a"b' }]],
-      [
-        'hello world',
-        [
-          { type: 'keyword', value: 'hello' },
-          { type: 'keyword', value: 'world' },
-        ],
-      ],
-      // advance
-      ['-a', [{ type: 'keyword', value: 'a', negative: true }]],
-      [
-        '/*Hi*/ hello -world',
-        [
-          { type: 'comment', value: 'Hi' },
-          { type: 'keyword', value: 'hello', negative: false },
-          {
-            type: 'keyword',
-            value: 'world',
-            negative: true,
-          },
-        ],
-      ],
-      ['"Hello"', [{ type: 'keyword', value: 'Hello', exact: true }]],
-      ['-"Hello"', [{ type: 'keyword', value: 'Hello', exact: true, negative: true }]],
-      ['is:ok', [{ type: 'compare', field: 'is', operator: 'match', value: { value: 'ok' } }]],
-      ['-is:ok', [{ type: 'compare', field: 'is', negative: true, operator: 'match', value: { value: 'ok' } }]],
-    ];
+		const cases: Case[] = [
+			[null, []],
+			[undefined, []],
+			['', []],
+			// fast path
+			['a', [{ type: 'keyword', value: 'a' }]],
+			['a-b', [{ type: 'keyword', value: 'a-b' }]],
+			['a"b', [{ type: 'keyword', value: 'a"b' }]],
+			[
+				'hello world',
+				[
+					{ type: 'keyword', value: 'hello' },
+					{ type: 'keyword', value: 'world' },
+				],
+			],
+			// advance
+			['-a', [{ type: 'keyword', value: 'a', negative: true }]],
+			[
+				'/*Hi*/ hello -world',
+				[
+					{ type: 'comment', value: 'Hi' },
+					{ type: 'keyword', value: 'hello', negative: false },
+					{ type: 'keyword', value: 'world', negative: true },
+				],
+			],
+			['"Hello"', [{ type: 'keyword', value: 'Hello', exact: true }]],
+			['-"Hello"', [{ type: 'keyword', value: 'Hello', exact: true, negative: true }]],
+			['is:ok', [{ type: 'compare', field: 'is', operator: 'match', value: { value: 'ok' } }]],
+			['-is:ok', [{ type: 'compare', field: 'is', negative: true, operator: 'match', value: { value: 'ok' } }]],
+		];
 
-    for (const [input, expected] of cases) {
-      let out = AdvanceSearch.parse(input);
-      expect(out).toMatchObject(expected);
-      expect(AdvanceSearch.parse(AdvanceSearch.format(out)), 'reformat should match').toMatchObject(expected);
-    }
-  });
+		for (const [input, expected] of cases) {
+			let out = AdvanceSearch.parse(input);
+			expect(out).toMatchObject(expected);
+			expect(AdvanceSearch.parse(AdvanceSearch.format(out)), 'reformat should match').toMatchObject(expected);
+		}
+	});
 
-  it('should optimize simple', () => {
-    type Case = {
-      input: AdvanceSearch.Expr[];
-      expected: AdvanceSearch.Expr[];
-    };
-    const cases: Case[] = [
-      // rm empty comment
-      {
-        input: [
-          { type: 'comment', value: '' },
-          { type: 'keyword', value: 'a' },
-        ],
-        expected: [{ type: 'keyword', value: 'a' }],
-      },
-      // unwrap parentheses
-      {
-        input: [
-          { type: 'parentheses', value: [{ type: 'keyword', value: 'a' }] },
-          { type: 'keyword', value: 'b' },
-        ],
-        expected: [
-          { type: 'keyword', value: 'a' },
-          { type: 'keyword', value: 'b' },
-        ],
-      },
-      // not not
-      {
-        input: [{ type: 'not', value: { type: 'not', value: { type: 'keyword', value: 'a' } } }],
-        expected: [{ type: 'keyword', value: 'a', negative: false }],
-      },
-      // not to negative
-      {
-        input: [{ type: 'not', value: { type: 'keyword', value: 'a' } }],
-        expected: [{ type: 'keyword', value: 'a', negative: true }],
-      },
-    ];
+	it('should optimize simple', () => {
+		type Case = { input: AdvanceSearch.Expr[]; expected: AdvanceSearch.Expr[] };
+		const cases: Case[] = [
+			// rm empty comment
+			{
+				input: [
+					{ type: 'comment', value: '' },
+					{ type: 'keyword', value: 'a' },
+				],
+				expected: [{ type: 'keyword', value: 'a' }],
+			},
+			// unwrap parentheses
+			{
+				input: [
+					{ type: 'parentheses', value: [{ type: 'keyword', value: 'a' }] },
+					{ type: 'keyword', value: 'b' },
+				],
+				expected: [
+					{ type: 'keyword', value: 'a' },
+					{ type: 'keyword', value: 'b' },
+				],
+			},
+			// not not
+			{
+				input: [{ type: 'not', value: { type: 'not', value: { type: 'keyword', value: 'a' } } }],
+				expected: [{ type: 'keyword', value: 'a', negative: false }],
+			},
+			// not to negative
+			{
+				input: [{ type: 'not', value: { type: 'keyword', value: 'a' } }],
+				expected: [{ type: 'keyword', value: 'a', negative: true }],
+			},
+		];
 
-    for (let i = 0; i < cases.length; i++) {
-      const { input, expected } = cases[i];
-      let out = AdvanceSearch.optimize(input);
-      expect(out, `case #${i}`).toEqual(expected);
-    }
-  });
+		for (let i = 0; i < cases.length; i++) {
+			const { input, expected } = cases[i];
+			let out = AdvanceSearch.optimize(input);
+			expect(out, `case #${i}`).toEqual(expected);
+		}
+	});
 
-  it('should optimize by formated', () => {
-    type Case = [string, string];
+	it('should optimize by formated', () => {
+		type Case = [string, string];
 
-    const cases: Case[] = [
-      ['( a )', 'a'],
-      ['NOT a', '-a'],
-      ['NOT -a', 'a'],
-      ['NOT is:ok', '-is:ok'],
-      ['NOT -is:ok', 'is:ok'],
-      ['NOT -is:=ok', 'is:=ok'],
-      ['NOT is:=ok', 'is:!=ok'],
-      ['NOT (NOT -a)', '-a'],
-    ];
+		const cases: Case[] = [
+			['( a )', 'a'],
+			['NOT a', '-a'],
+			['NOT -a', 'a'],
+			['NOT is:ok', '-is:ok'],
+			['NOT -is:ok', 'is:ok'],
+			['NOT -is:=ok', 'is:=ok'],
+			['NOT is:=ok', 'is:!=ok'],
+			['NOT (NOT -a)', '-a'],
+		];
 
-    for (const [input, expected] of cases) {
-      let out = AdvanceSearch.optimize(AdvanceSearch.parse(input));
-      expect(AdvanceSearch.format(out), `${input} -> ${expected}: ${JSON.stringify(out)}`).toEqual(expected);
-    }
-  });
+		for (const [input, expected] of cases) {
+			let out = AdvanceSearch.optimize(AdvanceSearch.parse(input));
+			expect(AdvanceSearch.format(out), `${input} -> ${expected}: ${JSON.stringify(out)}`).toEqual(expected);
+		}
+	});
 
-  it.fails('should parse parentheses', () => {
-    let out = AdvanceSearch.parse('(a)');
-    console.log(out);
-    expect(out).toEqual([{ type: 'parentheses', value: [{ type: 'keyword', value: 'a' }] }]);
-  });
+	it.fails('should parse parentheses', () => {
+		let out = AdvanceSearch.parse('(a)');
+		console.log(out);
+		expect(out).toEqual([{ type: 'parentheses', value: [{ type: 'keyword', value: 'a' }] }]);
+	});
 });

package/src/search/AdvanceSearch.ts

@@ -4,11 +4,11 @@ import { parseAdvanceSearch } from './parseAdvanceSearch';
 import type * as types from './types';
 
 export namespace AdvanceSearch {
-  export type Exprs = types.Exprs;
-  export type Expr = types.Expr;
-  export type Value = types.Value;
+	export type Exprs = types.Exprs;
+	export type Expr = types.Expr;
+	export type Value = types.Value;
 
-  export const parse = parseAdvanceSearch;
-  export const format = formatAdvanceSearch;
-  export const optimize = optimizeAdvanceSearch;
+	export const parse = parseAdvanceSearch;
+	export const format = formatAdvanceSearch;
+	export const optimize = optimizeAdvanceSearch;
 }

package/src/search/formatAdvanceSearch.ts

@@ -2,60 +2,51 @@ import { match } from 'ts-pattern';
 import { AdvanceSearch } from './AdvanceSearch';
 
 export function formatAdvanceSearch(input: AdvanceSearch.Expr[]) {
-  const OP = {
-    match: ':',
-    eq: ':=',
-    ne: ':!=',
-    gt: ':>',
-    lt: ':<',
-    gte: ':>=',
-    lte: ':<=',
-    range: ':',
-  } as const;
+	const OP = { match: ':', eq: ':=', ne: ':!=', gt: ':>', lt: ':<', gte: ':>=', lte: ':<=', range: ':' } as const;
 
-  const _exprs = (s: AdvanceSearch.Expr[]): string => {
-    return s.map(_expr).join(' ');
-  };
-  const _expr = (s: AdvanceSearch.Expr): string => {
-    return match(s)
-      .with({ type: 'keyword' }, ({ value, exact, negative }) => {
-        return `${negative ? '-' : ''}${exact ? `"${value}"` : value}`;
-      })
-      .with({ type: 'logical' }, ({ operator, value }) => value.map(_expr).join(` ${operator.toLocaleUpperCase()} `))
-      .with({ type: 'not' }, ({ value }) => `NOT ${_expr(value)}`)
-      .with({ type: 'compare' }, ({ field, operator, value, negative, mention }) => {
-        return `${negative ? '-' : ''}${mention ? '@' : ''}${field}${OP[operator]}${_value(value)}`;
-      })
-      .with({ type: 'comment' }, ({ value }) => `/* ${value} */`)
-      .with({ type: 'parentheses' }, ({ value }) => `(${_exprs(value)})`)
-      .exhaustive();
-  };
+	const _exprs = (s: AdvanceSearch.Expr[]): string => {
+		return s.map(_expr).join(' ');
+	};
+	const _expr = (s: AdvanceSearch.Expr): string => {
+		return match(s)
+			.with({ type: 'keyword' }, ({ value, exact, negative }) => {
+				return `${negative ? '-' : ''}${exact ? `"${value}"` : value}`;
+			})
+			.with({ type: 'logical' }, ({ operator, value }) => value.map(_expr).join(` ${operator.toLocaleUpperCase()} `))
+			.with({ type: 'not' }, ({ value }) => `NOT ${_expr(value)}`)
+			.with({ type: 'compare' }, ({ field, operator, value, negative, mention }) => {
+				return `${negative ? '-' : ''}${mention ? '@' : ''}${field}${OP[operator]}${_value(value)}`;
+			})
+			.with({ type: 'comment' }, ({ value }) => `/* ${value} */`)
+			.with({ type: 'parentheses' }, ({ value }) => `(${_exprs(value)})`)
+			.exhaustive();
+	};
 
-  const _literal = (s: string | null | number) => {
-    if (typeof s === 'string') {
-      return s.includes(' ') ? `"${s}"` : s;
-    }
-    return JSON.stringify(s);
-  };
-  const _value = (v: AdvanceSearch.Value): string => {
-    return match(v)
-      .with({ type: 'range' }, ({ minimum, maximum, minimumExclusive, maximumExclusive }) => {
-        if (minimumExclusive === undefined && maximumExclusive === undefined) {
-          let min = minimum === undefined ? '*' : _value(minimum);
-          let max = maximum === undefined ? '*' : _value(maximum);
-          return `${min}..${max}`;
-        }
-        let min = minimum === undefined ? '' : _value(minimum);
-        let max = maximum === undefined ? '' : _value(maximum);
-        return `${minimumExclusive ? '(' : '['}${min},${max}${maximumExclusive ? ')' : ']'}`;
-      })
-      .with({ format: 'mention' }, ({ value }) => {
-        return `@${value}`;
-      })
-      .otherwise((value) => {
-        return _literal(value.value);
-      });
-  };
+	const _literal = (s: string | null | number) => {
+		if (typeof s === 'string') {
+			return s.includes(' ') ? `"${s}"` : s;
+		}
+		return JSON.stringify(s);
+	};
+	const _value = (v: AdvanceSearch.Value): string => {
+		return match(v)
+			.with({ type: 'range' }, ({ minimum, maximum, minimumExclusive, maximumExclusive }) => {
+				if (minimumExclusive === undefined && maximumExclusive === undefined) {
+					let min = minimum === undefined ? '*' : _value(minimum);
+					let max = maximum === undefined ? '*' : _value(maximum);
+					return `${min}..${max}`;
+				}
+				let min = minimum === undefined ? '' : _value(minimum);
+				let max = maximum === undefined ? '' : _value(maximum);
+				return `${minimumExclusive ? '(' : '['}${min},${max}${maximumExclusive ? ')' : ']'}`;
+			})
+			.with({ format: 'mention' }, ({ value }) => {
+				return `@${value}`;
+			})
+			.otherwise((value) => {
+				return _literal(value.value);
+			});
+	};
 
-  return _exprs(input);
+	return _exprs(input);
 }

package/src/search/optimizeAdvanceSearch.ts

@@ -3,88 +3,75 @@ import { match } from 'ts-pattern';
 import { AdvanceSearch } from './AdvanceSearch';
 
 export function optimizeAdvanceSearch(expr: AdvanceSearch.Exprs): AdvanceSearch.Exprs {
-  const NEG = {
-    eq: 'ne',
-    ne: 'eq',
-    gt: 'lte',
-    lt: 'gte',
-    gte: 'lt',
-    lte: 'gt',
-  } as const;
-  const _expr = (e: AdvanceSearch.Expr): MaybeArray<AdvanceSearch.Expr> => {
-    // merge Exprs to AND ?
-    return (
-      match(e)
-        // (EXPR) -> EXPR
-        // TODO (EXPR EXPR) -> EXPR AND EXPR
-        .with({ type: 'parentheses' }, (expr) => {
-          // unwrap
-          if (expr.value.length < 2) {
-            return expr.value[0];
-          }
-          expr.value = expr.value.flatMap(_expr);
-          return expr;
-        })
-        .with({ type: 'comment' }, (expr) => {
-          // remove empty comment
-          if (!expr.value.length) {
-            return [];
-          }
-          return expr;
-        })
-        // NOT
-        .with({ type: 'not' }, (expr) => {
-          let out = arrayOfMaybeArray(_expr(expr.value));
-          if (!out.length) {
-            return [];
-          } else if (out.length === 1) {
-            expr.value = out[0];
-          } else {
-            throw new Error('NOT should have only one value');
-          }
-          return (
-            match(expr.value)
-              // NOT NOT EXPR -> EXPR
-              .with({ type: 'not' }, (expr) => expr.value)
-              // NOT EXPR -> -EXPR
-              .with({ type: 'compare' }, (expr) => {
-                return {
-                  ...expr,
-                  negative: !expr.negative,
-                };
-              })
-              .with({ type: 'keyword' }, (expr) => {
-                return {
-                  ...expr,
-                  negative: !expr.negative,
-                };
-              })
-              .otherwise(() => expr)
-          );
-        })
-        .with({ type: 'compare' }, (expr) => {
-          // negative by swap operator
-          if (expr.negative) {
-            const ne = NEG[expr.operator as keyof typeof NEG];
-            if (ne) {
-              expr.operator = ne;
-              expr.negative = false;
-            }
-          }
-          if (expr.operator === 'range') {
-          }
-          return expr;
-        })
-        .otherwise((e) => e)
-    );
-  };
+	const NEG = { eq: 'ne', ne: 'eq', gt: 'lte', lt: 'gte', gte: 'lt', lte: 'gt' } as const;
+	const _expr = (e: AdvanceSearch.Expr): MaybeArray<AdvanceSearch.Expr> => {
+		// merge Exprs to AND ?
+		return (
+			match(e)
+				// (EXPR) -> EXPR
+				// TODO (EXPR EXPR) -> EXPR AND EXPR
+				.with({ type: 'parentheses' }, (expr) => {
+					// unwrap
+					if (expr.value.length < 2) {
+						return expr.value[0];
+					}
+					expr.value = expr.value.flatMap(_expr);
+					return expr;
+				})
+				.with({ type: 'comment' }, (expr) => {
+					// remove empty comment
+					if (!expr.value.length) {
+						return [];
+					}
+					return expr;
+				})
+				// NOT
+				.with({ type: 'not' }, (expr) => {
+					let out = arrayOfMaybeArray(_expr(expr.value));
+					if (!out.length) {
+						return [];
+					} else if (out.length === 1) {
+						expr.value = out[0];
+					} else {
+						throw new Error('NOT should have only one value');
+					}
+					return (
+						match(expr.value)
+							// NOT NOT EXPR -> EXPR
+							.with({ type: 'not' }, (expr) => expr.value)
+							// NOT EXPR -> -EXPR
+							.with({ type: 'compare' }, (expr) => {
+								return { ...expr, negative: !expr.negative };
+							})
+							.with({ type: 'keyword' }, (expr) => {
+								return { ...expr, negative: !expr.negative };
+							})
+							.otherwise(() => expr)
+					);
+				})
+				.with({ type: 'compare' }, (expr) => {
+					// negative by swap operator
+					if (expr.negative) {
+						const ne = NEG[expr.operator as keyof typeof NEG];
+						if (ne) {
+							expr.operator = ne;
+							expr.negative = false;
+						}
+					}
+					if (expr.operator === 'range') {
+					}
+					return expr;
+				})
+				.otherwise((e) => e)
+		);
+	};
 
-  let last = expr;
-  while (true) {
-    let next = structuredClone(last).flatMap(_expr);
-    if (deepEqual(last, next)) {
-      return last;
-    }
-    last = next;
-  }
+	let last = expr;
+	while (true) {
+		let next = structuredClone(last).flatMap(_expr);
+		if (deepEqual(last, next)) {
+			return last;
+		}
+		last = next;
+	}
 }

package/src/search/parseAdvanceSearch.ts

@@ -2,25 +2,22 @@ import { AdvanceSearch } from './AdvanceSearch';
 import { parse } from './parser';
 
 export function parseAdvanceSearch(s: string | undefined | null): AdvanceSearch.Expr[] {
-  s = s?.trim();
-  if (!s) {
-    return [];
-  }
+	s = s?.trim();
+	if (!s) {
+		return [];
+	}
 
-  // no Logical, no Compare, no Quote, no Comment
-  if (!/AND|OR|NOT|[-"():]|\/\*/.test(s)) {
-    // fast path
-    return s
-      .split(/\s+/)
-      .map((v) => v.trim())
-      .filter(Boolean)
-      .map((v) => {
-        return {
-          type: 'keyword',
-          value: v,
-        };
-      });
-  }
+	// no Logical, no Compare, no Quote, no Comment
+	if (!/AND|OR|NOT|[-"():]|\/\*/.test(s)) {
+		// fast path
+		return s
+			.split(/\s+/)
+			.map((v) => v.trim())
+			.filter(Boolean)
+			.map((v) => {
+				return { type: 'keyword', value: v };
+			});
+	}
 
-  return parse(s);
+	return parse(s);
 }

package/src/search/parser.d.ts

@@ -1,8 +1,8 @@
 export function parse(input: string, options?: ParseOptions): any;
 
 export interface ParseOptions {
-  grammarSource?: string;
-  startRule?: string;
+	grammarSource?: string;
+	startRule?: string;
 
-  [k: string]: any;
+	[k: string]: any;
 }