@wener/common 2.0.1 → 2.0.2

package/lib/search/AdvanceSearch.js

@@ -1,9 +0,0 @@
-import { formatAdvanceSearch } from "./formatAdvanceSearch.js";
-import { optimizeAdvanceSearch } from "./optimizeAdvanceSearch.js";
-import { parseAdvanceSearch } from "./parseAdvanceSearch.js";
-(function (AdvanceSearch) {
-    AdvanceSearch.parse = parseAdvanceSearch;
-    AdvanceSearch.format = formatAdvanceSearch;
-    AdvanceSearch.optimize = optimizeAdvanceSearch;
-})(AdvanceSearch || (AdvanceSearch = {}));
-export var AdvanceSearch;

package/lib/search/AdvanceSearch.test.js

@@ -1,435 +0,0 @@
-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,78 +0,0 @@
-import { match } from 'ts-pattern';
-export function formatAdvanceSearch(input) {
-    var OP = {
-        match: ':',
-        eq: ':=',
-        ne: ':!=',
-        gt: ':>',
-        lt: ':<',
-        gte: ':>=',
-        lte: ':<=',
-        range: ':'
-    };
-    var _exprs = function(s) {
-        return s.map(_expr).join(' ');
-    };
-    var _expr = function(s) {
-        return match(s).with({
-            type: 'keyword'
-        }, function(param) {
-            var value = param.value, exact = param.exact, negative = param.negative;
-            return "".concat(negative ? '-' : '').concat(exact ? '"'.concat(value, '"') : value);
-        }).with({
-            type: 'logical'
-        }, function(param) {
-            var operator = param.operator, value = param.value;
-            return value.map(_expr).join(" ".concat(operator.toLocaleUpperCase(), " "));
-        }).with({
-            type: 'not'
-        }, function(param) {
-            var value = param.value;
-            return "NOT ".concat(_expr(value));
-        }).with({
-            type: 'compare'
-        }, 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'
-        }, function(param) {
-            var value = param.value;
-            return "/* ".concat(value, " */");
-        }).with({
-            type: 'parentheses'
-        }, function(param) {
-            var value = param.value;
-            return "(".concat(_exprs(value), ")");
-        }).exhaustive();
-    };
-    var _literal = function(s) {
-        if (typeof s === 'string') {
-            return s.includes(' ') ? '"'.concat(s, '"') : s;
-        }
-        return JSON.stringify(s);
-    };
-    var _value = function(v) {
-        return match(v).with({
-            type: 'range'
-        }, function(param) {
-            var minimum = param.minimum, maximum = param.maximum, minimumExclusive = param.minimumExclusive, maximumExclusive = param.maximumExclusive;
-            if (minimumExclusive === undefined && maximumExclusive === undefined) {
-                var min = minimum === undefined ? '*' : _value(minimum);
-                var max = maximum === undefined ? '*' : _value(maximum);
-                return "".concat(min, "..").concat(max);
-            }
-            var min1 = minimum === undefined ? '' : _value(minimum);
-            var max1 = maximum === undefined ? '' : _value(maximum);
-            return "".concat(minimumExclusive ? '(' : '[').concat(min1, ",").concat(max1).concat(maximumExclusive ? ')' : ']');
-        }).with({
-            format: 'mention'
-        }, function(param) {
-            var value = param.value;
-            return "@".concat(value);
-        }).otherwise(function(value) {
-            return _literal(value.value);
-        });
-    };
-    return _exprs(input);
-}

package/lib/search/index.js

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

package/lib/search/optimizeAdvanceSearch.js

@@ -1,143 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _object_spread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        if (enumerableOnly) {
-            symbols = symbols.filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-            });
-        }
-        keys.push.apply(keys, symbols);
-    }
-    return keys;
-}
-function _object_spread_props(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-        ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-    }
-    return target;
-}
-import { arrayOfMaybeArray, deepEqual } from '@wener/utils';
-import { match } from 'ts-pattern';
-export function optimizeAdvanceSearch(expr) {
-    var NEG = {
-        eq: 'ne',
-        ne: 'eq',
-        gt: 'lte',
-        lt: 'gte',
-        gte: 'lt',
-        lte: 'gt'
-    };
-    var _expr = function(e) {
-        // merge Exprs to AND ?
-        return match(e)// (EXPR) -> EXPR
-        // TODO (EXPR EXPR) -> EXPR AND EXPR
-        .with({
-            type: 'parentheses'
-        }, function(expr) {
-            // unwrap
-            if (expr.value.length < 2) {
-                return expr.value[0];
-            }
-            expr.value = expr.value.flatMap(_expr);
-            return expr;
-        }).with({
-            type: 'comment'
-        }, function(expr) {
-            // remove empty comment
-            if (!expr.value.length) {
-                return [];
-            }
-            return expr;
-        })// NOT
-        .with({
-            type: 'not'
-        }, function(expr) {
-            var 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'
-            }, function(expr) {
-                return expr.value;
-            })// NOT EXPR -> -EXPR
-            .with({
-                type: 'compare'
-            }, function(expr) {
-                return _object_spread_props(_object_spread({}, expr), {
-                    negative: !expr.negative
-                });
-            }).with({
-                type: 'keyword'
-            }, function(expr) {
-                return _object_spread_props(_object_spread({}, expr), {
-                    negative: !expr.negative
-                });
-            }).otherwise(function() {
-                return expr;
-            });
-        }).with({
-            type: 'compare'
-        }, function(expr) {
-            // negative by swap operator
-            if (expr.negative) {
-                var ne = NEG[expr.operator];
-                if (ne) {
-                    expr.operator = ne;
-                    expr.negative = false;
-                }
-            }
-            if (expr.operator === 'range') {}
-            return expr;
-        }).otherwise(function(e) {
-            return e;
-        });
-    };
-    var last = expr;
-    while(true){
-        var next = structuredClone(last).flatMap(_expr);
-        if (deepEqual(last, next)) {
-            return last;
-        }
-        last = next;
-    }
-}

package/lib/search/parseAdvanceSearch.js

@@ -1,20 +0,0 @@
-import { parse } from "./parser.js";
-export function parseAdvanceSearch(s) {
-    s = s === null || s === void 0 ? void 0 : 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(function (v) {
-            return v.trim();
-        }).filter(Boolean).map(function (v) {
-            return {
-                type: "keyword",
-                value: v
-            };
-        });
-    }
-    return parse(s);
-}

package/lib/search/parser.d.js

@@ -1 +0,0 @@
-export { };