@wener/common 1.0.4 → 2.0.1

package/lib/search/AdvanceSearch.test.js

@@ -0,0 +1,435 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr))
+        return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+        return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+                break;
+        }
+    }
+    catch (err) {
+        _d = true;
+        _e = err;
+    }
+    finally {
+        try {
+            if (!_n && _i["return"] != null)
+                _i["return"]();
+        }
+        finally {
+            if (_d)
+                throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { describe, expect, it } from "vitest";
+import { AdvanceSearch } from "./AdvanceSearch.js";
+describe("AdvanceSearch", function () {
+    it("should parse", function () {
+        for (var _i = 0, _iter = [
+            //
+            "-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 */"
+        ]; _i < _iter.length; _i++) {
+            var input = _iter[_i];
+            var out = AdvanceSearch.parse(input);
+            var formated = AdvanceSearch.format(out);
+            expect(formated, "reformat").toMatchSnapshot();
+            var 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", function () {
+        var cases = [
+            [
+                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"
+                        }
+                    }
+                ]
+            ]
+        ];
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for (var _iterator = cases[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                var _step_value = _sliced_to_array(_step.value, 2), input = _step_value[0], expected = _step_value[1];
+                var out = AdvanceSearch.parse(input);
+                expect(out).toMatchObject(expected);
+                expect(AdvanceSearch.parse(AdvanceSearch.format(out)), "reformat should match").toMatchObject(expected);
+            }
+        }
+        catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        }
+        finally {
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            }
+            finally {
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    });
+    it("should optimize simple", function () {
+        var cases = [
+            // 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 (var i = 0; i < cases.length; i++) {
+            var _cases_i = cases[i], input = _cases_i.input, expected = _cases_i.expected;
+            var out = AdvanceSearch.optimize(input);
+            expect(out, "case #".concat(i)).toEqual(expected);
+        }
+    });
+    it("should optimize by formated", function () {
+        var cases = [
+            [
+                "( 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"
+            ]
+        ];
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for (var _iterator = cases[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                var _step_value = _sliced_to_array(_step.value, 2), input = _step_value[0], expected = _step_value[1];
+                var out = AdvanceSearch.optimize(AdvanceSearch.parse(input));
+                expect(AdvanceSearch.format(out), "".concat(input, " -> ").concat(expected, ": ").concat(JSON.stringify(out))).toEqual(expected);
+            }
+        }
+        catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        }
+        finally {
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            }
+            finally {
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    });
+    it.fails("should parse parentheses", function () {
+        var out = AdvanceSearch.parse("(a)");
+        console.log(out);
+        expect(out).toEqual([
+            {
+                type: "parentheses",
+                value: [
+                    {
+                        type: "keyword",
+                        value: "a"
+                    }
+                ]
+            }
+        ]);
+    });
+});

package/lib/search/formatAdvanceSearch.js

@@ -1,6 +1,6 @@
-import { match } from "ts-pattern";
+import { match } from 'ts-pattern';
 export function formatAdvanceSearch(input) {
-    const OP = {
+    var OP = {
         match: ':',
         eq: ':=',
         ne: ':!=',
@@ -10,55 +10,69 @@ export function formatAdvanceSearch(input) {
         lte: ':<=',
         range: ':'
     };
-    const _exprs = (s)=>{
+    var _exprs = function(s) {
         return s.map(_expr).join(' ');
     };
-    const _expr = (s)=>{
+    var _expr = function(s) {
         return match(s).with({
             type: 'keyword'
-        }, ({ value, exact, negative })=>{
-            return `${negative ? '-' : ''}${exact ? `"${value}"` : value}`;
+        }, function(param) {
+            var value = param.value, exact = param.exact, negative = param.negative;
+            return "".concat(negative ? '-' : '').concat(exact ? '"'.concat(value, '"') : value);
         }).with({
             type: 'logical'
-        }, ({ operator, value })=>value.map(_expr).join(` ${operator.toLocaleUpperCase()} `)).with({
+        }, function(param) {
+            var operator = param.operator, value = param.value;
+            return value.map(_expr).join(" ".concat(operator.toLocaleUpperCase(), " "));
+        }).with({
             type: 'not'
-        }, ({ value })=>`NOT ${_expr(value)}`).with({
+        }, function(param) {
+            var value = param.value;
+            return "NOT ".concat(_expr(value));
+        }).with({
             type: 'compare'
-        }, ({ field, operator, value, negative, mention })=>{
-            return `${negative ? '-' : ''}${mention ? '@' : ''}${field}${OP[operator]}${_value(value)}`;
+        }, function(param) {
+            var field = param.field, operator = param.operator, value = param.value, negative = param.negative, mention = param.mention;
+            return "".concat(negative ? '-' : '').concat(mention ? '@' : '').concat(field).concat(OP[operator]).concat(_value(value));
         }).with({
             type: 'comment'
-        }, ({ value })=>`/* ${value} */`).with({
+        }, function(param) {
+            var value = param.value;
+            return "/* ".concat(value, " */");
+        }).with({
             type: 'parentheses'
-        }, ({ value })=>`(${_exprs(value)})`).exhaustive();
+        }, function(param) {
+            var value = param.value;
+            return "(".concat(_exprs(value), ")");
+        }).exhaustive();
     };
-    const _literal = (s)=>{
+    var _literal = function(s) {
         if (typeof s === 'string') {
-            return s.includes(' ') ? `"${s}"` : s;
+            return s.includes(' ') ? '"'.concat(s, '"') : s;
         }
         return JSON.stringify(s);
     };
-    const _value = (v)=>{
+    var _value = function(v) {
         return match(v).with({
             type: 'range'
-        }, ({ minimum, maximum, minimumExclusive, maximumExclusive })=>{
+        }, function(param) {
+            var minimum = param.minimum, maximum = param.maximum, minimumExclusive = param.minimumExclusive, maximumExclusive = param.maximumExclusive;
             if (minimumExclusive === undefined && maximumExclusive === undefined) {
-                let min = minimum === undefined ? '*' : _value(minimum);
-                let max = maximum === undefined ? '*' : _value(maximum);
-                return `${min}..${max}`;
+                var min = minimum === undefined ? '*' : _value(minimum);
+                var max = maximum === undefined ? '*' : _value(maximum);
+                return "".concat(min, "..").concat(max);
             }
-            let min = minimum === undefined ? '' : _value(minimum);
-            let max = maximum === undefined ? '' : _value(maximum);
-            return `${minimumExclusive ? '(' : '['}${min},${max}${maximumExclusive ? ')' : ']'}`;
+            var min1 = minimum === undefined ? '' : _value(minimum);
+            var max1 = maximum === undefined ? '' : _value(maximum);
+            return "".concat(minimumExclusive ? '(' : '[').concat(min1, ",").concat(max1).concat(maximumExclusive ? ')' : ']');
         }).with({
             format: 'mention'
-        }, ({ value })=>{
-            return `@${value}`;
-        }).otherwise((value)=>{
+        }, function(param) {
+            var value = param.value;
+            return "@".concat(value);
+        }).otherwise(function(value) {
             return _literal(value.value);
         });
     };
     return _exprs(input);
 }
-
-//# sourceMappingURL=formatAdvanceSearch.js.map

package/lib/search/index.js

@@ -1,2 +1 @@
 export { AdvanceSearch } from "./AdvanceSearch.js";
-//# sourceMappingURL=index.js.map