@chaoswise/intl 1.1.0 → 1.2.1

package/bin/scripts/util/FormPath/index.js

@@ -0,0 +1,536 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+}
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Path = void 0;
+var parser_1 = require("./parser");
+var utils_1 = require("./utils");
+var destructor_1 = require("./destructor");
+__exportStar(require("./types"), exports);
+var lru_1 = require("./lru");
+var matcher_1 = require("./matcher");
+var pathCache = new lru_1.LRUMap(1000);
+var isMatcher = Symbol('PATH_MATCHER');
+var isValid = function (val) { return val !== undefined && val !== null; };
+var arrayExist = function (obj, key) {
+    if (Array.isArray(obj)) {
+        var index = Number(key);
+        if (index < 0 || index > obj.length - 1)
+            return false;
+    }
+    return true;
+};
+var getIn = function (segments, source) {
+    for (var i = 0; i < segments.length; i++) {
+        var index = segments[i];
+        var rules = destructor_1.getDestructor(index);
+        if (!rules) {
+            if (!isValid(source)) {
+                if (i !== segments.length - 1) {
+                    return source;
+                }
+                break;
+            }
+            if (arrayExist(source, index)) {
+                source = source[index];
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            source = destructor_1.getInByDestructor(source, rules, { setIn: setIn, getIn: getIn });
+            break;
+        }
+    }
+    return source;
+};
+var setIn = function (segments, source, value) {
+    for (var i = 0; i < segments.length; i++) {
+        var index = segments[i];
+        var rules = destructor_1.getDestructor(index);
+        if (!rules) {
+            if (!isValid(source))
+                return;
+            if (!isValid(source[index])) {
+                if (!isValid(source[index]) && !isValid(value)) {
+                    return;
+                }
+                if (utils_1.isNum(segments[i + 1])) {
+                    source[index] = [];
+                }
+                else {
+                    source[index] = {};
+                }
+            }
+            if (i === segments.length - 1) {
+                source[index] = value;
+            }
+            if (arrayExist(source, index)) {
+                source = source[index];
+            }
+        }
+        else {
+            destructor_1.setInByDestructor(source, rules, value, { setIn: setIn, getIn: getIn });
+            break;
+        }
+    }
+};
+var deleteIn = function (segments, source) {
+    for (var i = 0; i < segments.length; i++) {
+        var index = segments[i];
+        var rules = destructor_1.getDestructor(index);
+        if (!rules) {
+            if (i === segments.length - 1 && isValid(source)) {
+                if (utils_1.isArr(source)) {
+                    source.splice(Number(index), 1);
+                }
+                else {
+                    delete source[index];
+                }
+                return;
+            }
+            if (!isValid(source))
+                return;
+            if (arrayExist(source, index)) {
+                source = source[index];
+            }
+            else {
+                return;
+            }
+            if (!utils_1.isObj(source)) {
+                return;
+            }
+        }
+        else {
+            destructor_1.deleteInByDestructor(source, rules, {
+                setIn: setIn,
+                getIn: getIn,
+                deleteIn: deleteIn,
+            });
+            break;
+        }
+    }
+};
+var existIn = function (segments, source, start) {
+    if (start instanceof Path) {
+        start = start.length;
+    }
+    for (var i = start; i < segments.length; i++) {
+        var index = segments[i];
+        var rules = destructor_1.getDestructor(index);
+        if (!rules) {
+            if (i === segments.length - 1) {
+                if (source && index in source) {
+                    return true;
+                }
+                return false;
+            }
+            if (!isValid(source))
+                return false;
+            if (arrayExist(source, index)) {
+                source = source[index];
+            }
+            else {
+                return false;
+            }
+            if (!utils_1.isObj(source)) {
+                return false;
+            }
+        }
+        else {
+            return destructor_1.existInByDestructor(source, rules, start, {
+                setIn: setIn,
+                getIn: getIn,
+                deleteIn: deleteIn,
+                existIn: existIn,
+            });
+        }
+    }
+};
+var Path = (function () {
+    function Path(input) {
+        var _this = this;
+        this.concat = function () {
+            var _a;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            if (_this.isMatchPattern) {
+                throw new Error(_this.entire + " cannot be concat");
+            }
+            var path = new Path('');
+            path.segments = (_a = _this.segments).concat.apply(_a, args.map(function (s) { return _this.parseString(s); }));
+            path.entire = path.segments.join('.');
+            return path;
+        };
+        this.slice = function (start, end) {
+            if (_this.isMatchPattern) {
+                throw new Error(_this.entire + " cannot be slice");
+            }
+            var path = new Path('');
+            path.segments = _this.segments.slice(start, end);
+            path.entire = path.segments.join('.');
+            return path;
+        };
+        this.push = function (item) {
+            if (_this.isMatchPattern) {
+                throw new Error(_this.entire + " cannot be push");
+            }
+            _this.segments.push(_this.parseString(item));
+            _this.entire = _this.segments.join('.');
+            return _this;
+        };
+        this.pop = function () {
+            if (_this.isMatchPattern) {
+                throw new Error(_this.entire + " cannot be pop");
+            }
+            _this.segments.pop();
+            _this.entire = _this.segments.join('.');
+        };
+        this.splice = function (start, deleteCount) {
+            var _a;
+            var items = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                items[_i - 2] = arguments[_i];
+            }
+            if (_this.isMatchPattern) {
+                throw new Error(_this.entire + " cannot be splice");
+            }
+            if (deleteCount === 0) {
+                items = items.map(function (item) { return _this.parseString(item); });
+            }
+            (_a = _this.segments).splice.apply(_a, __spreadArrays([start, deleteCount], items));
+            _this.entire = _this.segments.join('.');
+            return _this;
+        };
+        this.forEach = function (callback) {
+            if (_this.isMatchPattern) {
+                throw new Error(_this.entire + " cannot be each");
+            }
+            _this.segments.forEach(callback);
+        };
+        this.map = function (callback) {
+            if (_this.isMatchPattern) {
+                throw new Error(_this.entire + " cannot be map");
+            }
+            return _this.segments.map(callback);
+        };
+        this.reduce = function (callback, initial) {
+            if (_this.isMatchPattern) {
+                throw new Error(_this.entire + " cannot be reduce");
+            }
+            return _this.segments.reduce(callback, initial);
+        };
+        this.getNearestChildPathBy = function (target) {
+            var path = Path.parse(target);
+            if (path.length < _this.length)
+                return _this;
+            return _this.concat(path.segments[_this.length]);
+        };
+        this.parent = function () {
+            return _this.slice(0, _this.length - 1);
+        };
+        this.includes = function (pattern) {
+            var _a = Path.getPath(pattern), entire = _a.entire, segments = _a.segments, isMatchPattern = _a.isMatchPattern;
+            var cache = _this.includesCache.get(entire);
+            if (cache !== undefined)
+                return cache;
+            var cacheWith = function (value) {
+                _this.includesCache.set(entire, value);
+                return value;
+            };
+            if (_this.isMatchPattern) {
+                if (!isMatchPattern) {
+                    return cacheWith(_this.match(segments));
+                }
+                else {
+                    throw new Error(_this.entire + " cannot be used to match " + entire);
+                }
+            }
+            if (isMatchPattern) {
+                throw new Error(_this.entire + " cannot be used to match " + entire);
+            }
+            if (segments.length > _this.segments.length)
+                return cacheWith(false);
+            for (var i = 0; i < segments.length; i++) {
+                if (!utils_1.isEqual(String(segments[i]), String(_this.segments[i]))) {
+                    return cacheWith(false);
+                }
+            }
+            return cacheWith(true);
+        };
+        this.transform = function (regexp, callback) {
+            if (!utils_1.isFn(callback))
+                return '';
+            if (_this.isMatchPattern) {
+                throw new Error(_this.entire + " cannot be transformed");
+            }
+            var args = _this.segments.reduce(function (buf, key) {
+                return new RegExp(regexp).test(key) ? buf.concat(key) : buf;
+            }, []);
+            return callback.apply(void 0, args);
+        };
+        this.match = function (pattern) {
+            var path = Path.getPath(pattern);
+            var cache = _this.matchCache.get(path.entire);
+            if (cache !== undefined) {
+                if (cache.record && cache.record.score !== undefined) {
+                    _this.matchScore = cache.record.score;
+                }
+                return cache.matched;
+            }
+            var cacheWith = function (value) {
+                _this.matchCache.set(path.entire, value);
+                return value;
+            };
+            if (path.isMatchPattern) {
+                if (_this.isMatchPattern) {
+                    throw new Error(path.entire + " cannot match " + _this.entire);
+                }
+                else {
+                    _this.matchScore = 0;
+                    return cacheWith(path.match(_this.segments));
+                }
+            }
+            else {
+                if (_this.isMatchPattern) {
+                    var record = {
+                        score: 0,
+                    };
+                    var result = cacheWith(new matcher_1.Matcher(_this.tree, record).match(path.segments));
+                    _this.matchScore = record.score;
+                    return result.matched;
+                }
+                else {
+                    var record = {
+                        score: 0,
+                    };
+                    var result = cacheWith(matcher_1.Matcher.matchSegments(_this.segments, path.segments, record));
+                    _this.matchScore = record.score;
+                    return result.matched;
+                }
+            }
+        };
+        this.matchAliasGroup = function (name, alias) {
+            var namePath = Path.parse(name);
+            var aliasPath = Path.parse(alias);
+            var nameMatched = _this.match(namePath);
+            var nameMatchedScore = _this.matchScore;
+            var aliasMatched = _this.match(aliasPath);
+            var aliasMatchedScore = _this.matchScore;
+            if (_this.haveExcludePattern) {
+                if (nameMatchedScore >= aliasMatchedScore) {
+                    return nameMatched;
+                }
+                else {
+                    return aliasMatched;
+                }
+            }
+            else {
+                return nameMatched || aliasMatched;
+            }
+        };
+        this.existIn = function (source, start) {
+            if (start === void 0) { start = 0; }
+            return existIn(_this.segments, source, start);
+        };
+        this.getIn = function (source) {
+            return getIn(_this.segments, source);
+        };
+        this.setIn = function (source, value) {
+            setIn(_this.segments, source, value);
+            return source;
+        };
+        this.deleteIn = function (source) {
+            deleteIn(_this.segments, source);
+            return source;
+        };
+        var _a = this.parse(input), tree = _a.tree, segments = _a.segments, entire = _a.entire, isMatchPattern = _a.isMatchPattern, isWildMatchPattern = _a.isWildMatchPattern, haveExcludePattern = _a.haveExcludePattern;
+        this.entire = entire;
+        this.segments = segments;
+        this.isMatchPattern = isMatchPattern;
+        this.isWildMatchPattern = isWildMatchPattern;
+        this.haveExcludePattern = haveExcludePattern;
+        this.tree = tree;
+        this.matchCache = new lru_1.LRUMap(200);
+        this.includesCache = new lru_1.LRUMap(200);
+    }
+    Path.prototype.toString = function () {
+        return this.entire;
+    };
+    Path.prototype.toArray = function () {
+        return this.segments;
+    };
+    Object.defineProperty(Path.prototype, "length", {
+        get: function () {
+            return this.segments.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Path.prototype.parse = function (pattern) {
+        var _this = this;
+        if (pattern instanceof Path) {
+            return {
+                entire: pattern.entire,
+                segments: pattern.segments.slice(),
+                isWildMatchPattern: pattern.isWildMatchPattern,
+                isMatchPattern: pattern.isMatchPattern,
+                haveExcludePattern: pattern.haveExcludePattern,
+                tree: pattern.tree,
+            };
+        }
+        else if (utils_1.isStr(pattern)) {
+            if (!pattern)
+                return {
+                    entire: '',
+                    segments: [],
+                    isWildMatchPattern: false,
+                    haveExcludePattern: false,
+                    isMatchPattern: false,
+                };
+            var parser = new parser_1.Parser(pattern);
+            var tree = parser.parse();
+            if (!parser.isMatchPattern) {
+                var segments = parser.data.segments;
+                return {
+                    entire: segments.join('.'),
+                    segments: segments,
+                    tree: tree,
+                    isWildMatchPattern: false,
+                    haveExcludePattern: false,
+                    isMatchPattern: false,
+                };
+            }
+            else {
+                return {
+                    entire: pattern,
+                    segments: [],
+                    isWildMatchPattern: parser.isWildMatchPattern,
+                    haveExcludePattern: parser.haveExcludePattern,
+                    isMatchPattern: true,
+                    tree: tree,
+                };
+            }
+        }
+        else if (utils_1.isFn(pattern) && pattern[isMatcher]) {
+            return this.parse(pattern['path']);
+        }
+        else if (utils_1.isArr(pattern)) {
+            return {
+                entire: pattern.join('.'),
+                segments: pattern.reduce(function (buf, key) {
+                    return buf.concat(_this.parseString(key));
+                }, []),
+                isWildMatchPattern: false,
+                haveExcludePattern: false,
+                isMatchPattern: false,
+            };
+        }
+        else {
+            return {
+                entire: '',
+                segments: pattern !== undefined ? [pattern] : [],
+                isWildMatchPattern: false,
+                haveExcludePattern: false,
+                isMatchPattern: false,
+            };
+        }
+    };
+    Path.prototype.parseString = function (source) {
+        if (utils_1.isStr(source)) {
+            source = source.replace(/\s*/g, '');
+            try {
+                var _a = this.parse(source), segments = _a.segments, isMatchPattern = _a.isMatchPattern;
+                return !isMatchPattern ? segments : source;
+            }
+            catch (e) {
+                return source;
+            }
+        }
+        else if (source instanceof Path) {
+            return source.segments;
+        }
+        return source;
+    };
+    Path.match = function (pattern) {
+        var path = Path.getPath(pattern);
+        var matcher = function (target) {
+            return path.match(target);
+        };
+        matcher[isMatcher] = true;
+        matcher.path = path;
+        return matcher;
+    };
+    Path.transform = function (pattern, regexp, callback) {
+        return Path.getPath(pattern).transform(regexp, callback);
+    };
+    Path.parse = function (path) {
+        if (path === void 0) { path = ''; }
+        return Path.getPath(path);
+    };
+    Path.getPath = function (path) {
+        if (path === void 0) { path = ''; }
+        if (path instanceof Path) {
+            var found = pathCache.get(path.entire);
+            if (found) {
+                return found;
+            }
+            else {
+                pathCache.set(path.entire, path);
+                return path;
+            }
+        }
+        else if (path && path[isMatcher]) {
+            return Path.getPath(path['path']);
+        }
+        else {
+            var key = path.toString();
+            var found = pathCache.get(key);
+            if (found) {
+                return found;
+            }
+            else {
+                path = new Path(path);
+                pathCache.set(key, path);
+                return path;
+            }
+        }
+    };
+    Path.getIn = function (source, pattern) {
+        var path = Path.getPath(pattern);
+        return path.getIn(source);
+    };
+    Path.setIn = function (source, pattern, value) {
+        var path = Path.getPath(pattern);
+        return path.setIn(source, value);
+    };
+    Path.deleteIn = function (source, pattern) {
+        var path = Path.getPath(pattern);
+        return path.deleteIn(source);
+    };
+    Path.existIn = function (source, pattern, start) {
+        var path = Path.getPath(pattern);
+        return path.existIn(source, start);
+    };
+    return Path;
+}());
+exports.Path = Path;
+exports.default = Path;

package/bin/scripts/util/FormPath/lru.d.ts

@@ -0,0 +1 @@
+export declare function LRUMap(limit: number, entries?: any): void;