@chaoswise/intl 1.0.0 → 1.2.0

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

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUMap = void 0;
+var NEWER = Symbol('newer');
+var OLDER = Symbol('older');
+function LRUMap(limit, entries) {
+    if (typeof limit !== 'number') {
+        entries = limit;
+        limit = 0;
+    }
+    this.size = 0;
+    this.limit = limit;
+    this.oldest = this.newest = undefined;
+    this._keymap = new Map();
+    if (entries) {
+        this.assign(entries);
+        if (limit < 1) {
+            this.limit = this.size;
+        }
+    }
+}
+exports.LRUMap = LRUMap;
+function Entry(key, value) {
+    this.key = key;
+    this.value = value;
+    this[NEWER] = undefined;
+    this[OLDER] = undefined;
+}
+LRUMap.prototype._markEntryAsUsed = function (entry) {
+    if (entry === this.newest) {
+        return;
+    }
+    if (entry[NEWER]) {
+        if (entry === this.oldest) {
+            this.oldest = entry[NEWER];
+        }
+        entry[NEWER][OLDER] = entry[OLDER];
+    }
+    if (entry[OLDER]) {
+        entry[OLDER][NEWER] = entry[NEWER];
+    }
+    entry[NEWER] = undefined;
+    entry[OLDER] = this.newest;
+    if (this.newest) {
+        this.newest[NEWER] = entry;
+    }
+    this.newest = entry;
+};
+LRUMap.prototype.assign = function (entries) {
+    var entry;
+    var limit = this.limit || Number.MAX_VALUE;
+    this._keymap.clear();
+    var it = entries[Symbol.iterator]();
+    for (var itv = it.next(); !itv.done; itv = it.next()) {
+        var e = new Entry(itv.value[0], itv.value[1]);
+        this._keymap.set(e.key, e);
+        if (!entry) {
+            this.oldest = e;
+        }
+        else {
+            entry[NEWER] = e;
+            e[OLDER] = entry;
+        }
+        entry = e;
+        if (limit-- === 0) {
+            throw new Error('overflow');
+        }
+    }
+    this.newest = entry;
+    this.size = this._keymap.size;
+};
+LRUMap.prototype.get = function (key) {
+    var entry = this._keymap.get(key);
+    if (!entry) {
+        return;
+    }
+    this._markEntryAsUsed(entry);
+    return entry.value;
+};
+LRUMap.prototype.set = function (key, value) {
+    var entry = this._keymap.get(key);
+    if (entry) {
+        entry.value = value;
+        this._markEntryAsUsed(entry);
+        return this;
+    }
+    this._keymap.set(key, (entry = new Entry(key, value)));
+    if (this.newest) {
+        this.newest[NEWER] = entry;
+        entry[OLDER] = this.newest;
+    }
+    else {
+        this.oldest = entry;
+    }
+    this.newest = entry;
+    ++this.size;
+    if (this.size > this.limit) {
+        this.shift();
+    }
+    return this;
+};
+LRUMap.prototype.shift = function () {
+    var entry = this.oldest;
+    if (entry) {
+        if (this.oldest[NEWER]) {
+            this.oldest = this.oldest[NEWER];
+            this.oldest[OLDER] = undefined;
+        }
+        else {
+            this.oldest = undefined;
+            this.newest = undefined;
+        }
+        entry[NEWER] = entry[OLDER] = undefined;
+        this._keymap.delete(entry.key);
+        --this.size;
+        return [entry.key, entry.value];
+    }
+};
+LRUMap.prototype.find = function (key) {
+    var e = this._keymap.get(key);
+    return e ? e.value : undefined;
+};
+LRUMap.prototype.has = function (key) {
+    return this._keymap.has(key);
+};
+LRUMap.prototype.delete = function (key) {
+    var entry = this._keymap.get(key);
+    if (!entry) {
+        return;
+    }
+    this._keymap.delete(entry.key);
+    if (entry[NEWER] && entry[OLDER]) {
+        entry[OLDER][NEWER] = entry[NEWER];
+        entry[NEWER][OLDER] = entry[OLDER];
+    }
+    else if (entry[NEWER]) {
+        entry[NEWER][OLDER] = undefined;
+        this.oldest = entry[NEWER];
+    }
+    else if (entry[OLDER]) {
+        entry[OLDER][NEWER] = undefined;
+        this.newest = entry[OLDER];
+    }
+    else {
+        this.oldest = this.newest = undefined;
+    }
+    this.size--;
+    return entry.value;
+};
+LRUMap.prototype.clear = function () {
+    this.oldest = this.newest = undefined;
+    this.size = 0;
+    this._keymap.clear();
+};
+function EntryIterator(oldestEntry) {
+    this.entry = oldestEntry;
+}
+EntryIterator.prototype[Symbol.iterator] = function () {
+    return this;
+};
+EntryIterator.prototype.next = function () {
+    var ent = this.entry;
+    if (ent) {
+        this.entry = ent[NEWER];
+        return { done: false, value: [ent.key, ent.value] };
+    }
+    else {
+        return { done: true, value: undefined };
+    }
+};
+function KeyIterator(oldestEntry) {
+    this.entry = oldestEntry;
+}
+KeyIterator.prototype[Symbol.iterator] = function () {
+    return this;
+};
+KeyIterator.prototype.next = function () {
+    var ent = this.entry;
+    if (ent) {
+        this.entry = ent[NEWER];
+        return { done: false, value: ent.key };
+    }
+    else {
+        return { done: true, value: undefined };
+    }
+};
+function ValueIterator(oldestEntry) {
+    this.entry = oldestEntry;
+}
+ValueIterator.prototype[Symbol.iterator] = function () {
+    return this;
+};
+ValueIterator.prototype.next = function () {
+    var ent = this.entry;
+    if (ent) {
+        this.entry = ent[NEWER];
+        return { done: false, value: ent.value };
+    }
+    else {
+        return { done: true, value: undefined };
+    }
+};
+LRUMap.prototype.keys = function () {
+    return new KeyIterator(this.oldest);
+};
+LRUMap.prototype.values = function () {
+    return new ValueIterator(this.oldest);
+};
+LRUMap.prototype.entries = function () {
+    return this;
+};
+LRUMap.prototype[Symbol.iterator] = function () {
+    return new EntryIterator(this.oldest);
+};
+LRUMap.prototype.forEach = function (fun, thisObj) {
+    if (typeof thisObj !== 'object') {
+        thisObj = this;
+    }
+    var entry = this.oldest;
+    while (entry) {
+        fun.call(thisObj, entry.value, entry.key, this);
+        entry = entry[NEWER];
+    }
+};
+LRUMap.prototype.toJSON = function () {
+    var s = new Array(this.size);
+    var i = 0;
+    var entry = this.oldest;
+    while (entry) {
+        s[i++] = { key: entry.key, value: entry.value };
+        entry = entry[NEWER];
+    }
+    return s;
+};
+LRUMap.prototype.toString = function () {
+    var s = '';
+    var entry = this.oldest;
+    while (entry) {
+        s += String(entry.key) + ':' + entry.value;
+        entry = entry[NEWER];
+        if (entry) {
+            s += ' < ';
+        }
+    }
+    return s;
+};

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

@@ -0,0 +1,33 @@
+import { Segments, Node, IdentifierNode, IgnoreExpressionNode, DestructorExpressionNode, ExpandOperatorNode, WildcardOperatorNode, GroupExpressionNode, RangeExpressionNode, DotOperatorNode } from './types';
+export declare class Matcher {
+    private tree;
+    private pos;
+    private tail;
+    private stack;
+    private excluding;
+    private record;
+    constructor(tree: Node, record?: any);
+    currentElement(path: Segments): string;
+    matchNext: (node: any, path: any) => any;
+    recordMatch(match: () => boolean): () => boolean;
+    matchIdentifier(path: Segments, node: IdentifierNode): any;
+    matchIgnoreExpression(path: Segments, node: IgnoreExpressionNode): any;
+    matchDestructorExpression(path: Segments, node: DestructorExpressionNode): any;
+    matchExpandOperator(path: Segments, node: ExpandOperatorNode): any;
+    matchWildcardOperator(path: Segments, node: WildcardOperatorNode): any;
+    matchGroupExpression(path: Segments, node: GroupExpressionNode): any;
+    matchRangeExpression(path: Segments, node: RangeExpressionNode): boolean;
+    matchDotOperator(path: Segments, node: DotOperatorNode): any;
+    matchAtom(path: Segments, node: Node): any;
+    match(path: Segments): {
+        matched: boolean;
+        record?: undefined;
+    } | {
+        matched: any;
+        record: any;
+    };
+    static matchSegments(source: Segments, target: Segments, record?: any): false | {
+        matched: any;
+        record: any;
+    };
+}

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

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Matcher = void 0;
+var types_1 = require("./types");
+var utils_1 = require("./utils");
+var isValid = function (val) { return val !== undefined && val !== null && val !== ''; };
+var Matcher = (function () {
+    function Matcher(tree, record) {
+        var _this = this;
+        this.matchNext = function (node, path) {
+            return node.after
+                ? _this.matchAtom(path, node.after)
+                : isValid(path[_this.pos]);
+        };
+        this.tree = tree;
+        this.pos = 0;
+        this.excluding = false;
+        this.record = record;
+        this.stack = [];
+    }
+    Matcher.prototype.currentElement = function (path) {
+        return String(path[this.pos] || '').replace(/\s*/g, '');
+    };
+    Matcher.prototype.recordMatch = function (match) {
+        var _this = this;
+        return function () {
+            var result = match();
+            if (result) {
+                if (_this.record && _this.record.score !== undefined) {
+                    _this.record.score++;
+                }
+            }
+            return result;
+        };
+    };
+    Matcher.prototype.matchIdentifier = function (path, node) {
+        var _this = this;
+        this.tail = node;
+        if (isValid(path[this.pos + 1]) && !node.after) {
+            if (this.stack.length) {
+                for (var i = this.stack.length - 1; i >= 0; i--) {
+                    if (!this.stack[i].after || !this.stack[i].filter) {
+                        return false;
+                    }
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        var current;
+        var next = function () {
+            return _this.matchNext(node, path);
+        };
+        if (types_1.isExpandOperator(node.after)) {
+            current = this.recordMatch(function () {
+                return node.value === String(path[_this.pos]).substring(0, node.value.length);
+            });
+        }
+        else {
+            current = this.recordMatch(function () {
+                return utils_1.isEqual(String(node.value), String(path[_this.pos]));
+            });
+        }
+        if (this.excluding) {
+            if (node.after) {
+                if (this.pos < path.length) {
+                    return current() && next();
+                }
+                else {
+                    if (node.after && types_1.isWildcardOperator(node.after.after)) {
+                        return true;
+                    }
+                    return false;
+                }
+            }
+            else {
+                if (this.pos >= path.length) {
+                    return true;
+                }
+                return current();
+            }
+        }
+        return current() && next();
+    };
+    Matcher.prototype.matchIgnoreExpression = function (path, node) {
+        return (utils_1.isEqual(node.value, this.currentElement(path)) &&
+            this.matchNext(node, path));
+    };
+    Matcher.prototype.matchDestructorExpression = function (path, node) {
+        return (utils_1.isEqual(node.source, this.currentElement(path)) &&
+            this.matchNext(node, path));
+    };
+    Matcher.prototype.matchExpandOperator = function (path, node) {
+        return this.matchAtom(path, node.after);
+    };
+    Matcher.prototype.matchWildcardOperator = function (path, node) {
+        this.tail = node;
+        this.stack.push(node);
+        var matched = false;
+        if (node.filter) {
+            if (node.after) {
+                matched =
+                    this.matchAtom(path, node.filter) && this.matchAtom(path, node.after);
+            }
+            else {
+                matched = this.matchAtom(path, node.filter);
+            }
+        }
+        else {
+            matched = this.matchNext(node, path);
+        }
+        this.stack.pop();
+        return matched;
+    };
+    Matcher.prototype.matchGroupExpression = function (path, node) {
+        var _this = this;
+        var current = this.pos;
+        this.excluding = !!node.isExclude;
+        var method = this.excluding ? 'every' : 'some';
+        var result = utils_1.toArray(node.value)[method](function (_node) {
+            _this.pos = current;
+            return _this.excluding
+                ? !_this.matchAtom(path, _node)
+                : _this.matchAtom(path, _node);
+        });
+        this.excluding = false;
+        return result;
+    };
+    Matcher.prototype.matchRangeExpression = function (path, node) {
+        if (node.start) {
+            if (node.end) {
+                return (path[this.pos] >= parseInt(node.start.value) &&
+                    path[this.pos] <= parseInt(node.end.value));
+            }
+            else {
+                return path[this.pos] >= parseInt(node.start.value);
+            }
+        }
+        else {
+            if (node.end) {
+                return path[this.pos] <= parseInt(node.end.value);
+            }
+            else {
+                return true;
+            }
+        }
+    };
+    Matcher.prototype.matchDotOperator = function (path, node) {
+        this.pos++;
+        return this.matchNext(node, path);
+    };
+    Matcher.prototype.matchAtom = function (path, node) {
+        if (!node) {
+            if (this.stack.length > 0)
+                return true;
+            if (isValid(path[this.pos + 1]))
+                return false;
+            if (this.pos == path.length - 1)
+                return true;
+        }
+        if (types_1.isIdentifier(node)) {
+            return this.matchIdentifier(path, node);
+        }
+        else if (types_1.isIgnoreExpression(node)) {
+            return this.matchIgnoreExpression(path, node);
+        }
+        else if (types_1.isDestructorExpression(node)) {
+            return this.matchDestructorExpression(path, node);
+        }
+        else if (types_1.isExpandOperator(node)) {
+            return this.matchExpandOperator(path, node);
+        }
+        else if (types_1.isWildcardOperator(node)) {
+            return this.matchWildcardOperator(path, node);
+        }
+        else if (types_1.isGroupExpression(node)) {
+            return this.matchGroupExpression(path, node);
+        }
+        else if (types_1.isRangeExpression(node)) {
+            return this.matchRangeExpression(path, node);
+        }
+        else if (types_1.isDotOperator(node)) {
+            return this.matchDotOperator(path, node);
+        }
+        return true;
+    };
+    Matcher.prototype.match = function (path) {
+        var matched = this.matchAtom(path, this.tree);
+        if (!this.tail)
+            return { matched: false };
+        if (this.tail == this.tree && types_1.isWildcardOperator(this.tail)) {
+            return { matched: true };
+        }
+        return { matched: matched, record: this.record };
+    };
+    Matcher.matchSegments = function (source, target, record) {
+        var pos = 0;
+        if (source.length !== target.length)
+            return false;
+        var match = function (pos) {
+            var current = function () {
+                var res = utils_1.isEqual(source[pos], target[pos]);
+                if (record && record.score !== undefined) {
+                    record.score++;
+                }
+                return res;
+            };
+            var next = function () { return (pos < source.length - 1 ? match(pos + 1) : true); };
+            return current() && next();
+        };
+        return { matched: match(pos), record: record };
+    };
+    return Matcher;
+}());
+exports.Matcher = Matcher;

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

@@ -0,0 +1,28 @@
+import { Tokenizer } from './tokenizer';
+import { Token } from './tokens';
+import { IdentifierNode, ExpandOperatorNode, WildcardOperatorNode, RangeExpressionNode, GroupExpressionNode, IgnoreExpressionNode, DestructorExpressionNode, ObjectPatternNode, ObjectPatternPropertyNode, ArrayPatternNode, Node, Segments } from './types';
+export declare class Parser extends Tokenizer {
+    isMatchPattern: boolean;
+    isWildMatchPattern: boolean;
+    haveExcludePattern: boolean;
+    data: {
+        segments: Segments;
+        tree?: Node;
+    };
+    parse(): Node;
+    append(parent: Node, node: Node): void;
+    parseAtom(type: Token): Node;
+    pushSegments(key: string | number): void;
+    parseIdentifier(): IdentifierNode;
+    parseExpandOperator(): ExpandOperatorNode;
+    parseWildcardOperator(): WildcardOperatorNode;
+    parseDestructorExpression(): DestructorExpressionNode;
+    parseArrayPattern(): ArrayPatternNode;
+    parseArrayPatternElements(): any[];
+    parseObjectPattern(): ObjectPatternNode;
+    parseObjectProperties(): ObjectPatternPropertyNode[];
+    parseDotOperator(): Node;
+    parseIgnoreExpression(): IgnoreExpressionNode;
+    parseGroupExpression(parent: Node): GroupExpressionNode;
+    parseRangeExpression(parent: Node): RangeExpressionNode;
+}