@wener/common 1.0.1 → 1.0.2

package/src/search/formatAdvanceSearch.ts

@@ -0,0 +1,61 @@
+import { match } from 'ts-pattern';
+import { AdvanceSearch } from './AdvanceSearch';
+
+export function formatAdvanceSearch(input: AdvanceSearch.Expr[]) {
+  const OP = {
+    has: ':',
+    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 _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);
+}

package/src/search/index.ts

@@ -0,0 +1 @@
+export { AdvanceSearch } from './AdvanceSearch';

package/src/search/optimizeAdvanceSearch.ts

@@ -0,0 +1,90 @@
+import { arrayOfMaybeArray, deepEqual, type MaybeArray } from '@wener/utils';
+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)
+    );
+  };
+
+  let last = expr;
+  while (true) {
+    let next = structuredClone(last).flatMap(_expr);
+    if (deepEqual(last, next)) {
+      return last;
+    }
+    last = next;
+  }
+}

package/src/search/parseAdvanceSearch.ts

@@ -0,0 +1,26 @@
+import { AdvanceSearch } from './AdvanceSearch';
+import { parse } from './parser';
+
+export function parseAdvanceSearch(s: string | undefined | null): AdvanceSearch.Expr[] {
+  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,
+        };
+      });
+  }
+
+  return parse(s);
+}

package/src/search/parser.d.ts

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