econ - npm Package Compare versions

Comparing version 0.0.1 to 0.0.2

CODE_OF_CONDUCT.md

@@ -0,0 +0,0 @@ # Contributor Covenant Code of Conduct

CONTRIBUTING.md

@@ -0,0 +0,0 @@ # Contribution Guide

lib/basic/CollectionEvent.d.ts

 import * as std from "tstl";
-export declare class CollectionEvent<T, SourceT extends std.base.Container<T, SourceT, IteratorT, ReverseT>, IteratorT extends std.base.Iterator<T, SourceT, IteratorT, ReverseT>, ReverseT extends std.base.ReverseIterator<T, SourceT, IteratorT, ReverseT>> {
-    private type_;
-    private first_;
-    private last_;
-    constructor(type: string, first: IteratorT, last: IteratorT);
+export declare class CollectionEvent<T, SourceT extends std.base.Container<T, SourceT, IteratorT, ReverseT>, IteratorT extends std.base.Iterator<T, SourceT, IteratorT, ReverseT>, ReverseT extends std.base.ReverseIterator<T, SourceT, IteratorT, ReverseT>> implements Iterable<T> {
     readonly type: string;
     readonly first: IteratorT;
     readonly last: IteratorT;
+    constructor(type: string, first: IteratorT, last: IteratorT);
+    [Symbol.iterator](): IterableIterator<T>;
 }
@@ -11,0 +9,0 @@ export declare namespace CollectionEvent {

lib/basic/CollectionEvent.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+var std = require("tstl");
 var CollectionEvent = /** @class */ (function () {
     function CollectionEvent(type, first, last) {
-        this.type_ = type;
-        this.first_ = first;
-        this.last_ = last;
+        this.type = type;
+        this.first = first;
+        this.last = last;
     }
-    Object.defineProperty(CollectionEvent.prototype, "type", {
-        get: function () {
-            return this.type_;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CollectionEvent.prototype, "first", {
-        get: function () {
-            return this.first_;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CollectionEvent.prototype, "last", {
-        get: function () {
-            return this.last_;
-        },
-        enumerable: true,
-        configurable: true
-    });
+    CollectionEvent.prototype[Symbol.iterator] = function () {
+        return new std.base.ForOfAdaptor(this.first, this.last);
+    };
     return CollectionEvent;
@@ -31,0 +14,0 @@ }());

lib/basic/EventDispatcher.d.ts

@@ -0,0 +0,0 @@ import * as std from "tstl";

lib/basic/EventDispatcher.js

@@ -0,0 +0,0 @@ "use strict";

lib/basic/ICollection.d.ts

@@ -0,0 +0,0 @@ import * as std from "tstl";

lib/basic/ICollection.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=ICollection.js.map

lib/basic/IEventDispatcher.d.ts

@@ -0,0 +0,0 @@ import * as std from "tstl";

lib/basic/IEventDispatcher.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=IEventDispatcher.js.map

lib/index.d.ts

@@ -0,0 +0,0 @@ export * from "./basic/CollectionEvent";

lib/index.js

@@ -0,0 +0,0 @@ "use strict";

lib/linear/Deque.d.ts

@@ -9,2 +9,3 @@ import * as std from "tstl";
     private dispatcher_;
+    clear(): void;
     /**
@@ -11,0 +12,0 @@ * @inheritdoc

lib/linear/Deque.js

@@ -26,2 +26,12 @@ "use strict";
     }
+    /* ---------------------------------------------------------
+        CONSTRUCTORS
+    --------------------------------------------------------- */
+    // using super.constructor;
+    Deque.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        this._Notify_erase(first, last);
+        _super.prototype.clear.call(this);
+    };
     /* =========================================================
@@ -115,3 +125,4 @@ ELEMENTS I/O
     Deque.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -160,2 +171,10 @@ /**
 exports.Deque = Deque;
+var old_swap = std.Deque.prototype.swap;
+std.Deque.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof Deque)
+        this.refresh();
+    if (obj instanceof Deque)
+        obj.refresh();
+};
 //# sourceMappingURL=Deque.js.map

lib/linear/List.d.ts

@@ -9,9 +9,6 @@ import * as std from "tstl";
     private dispatcher_;
+    clear(): void;
     /**
      * @hidden
      */
-    protected _Create_iterator(prev: std.List.Iterator<T>, next: std.List.Iterator<T>, val: T): std.List.Iterator<T>;
-    /**
-     * @hidden
-     */
     protected _Insert_by_range<U extends T, InputIterator extends std.IForwardIterator<U, InputIterator>>(pos: std.List.Iterator<T>, first: InputIterator, last: InputIterator): std.List.Iterator<T>;
@@ -23,2 +20,14 @@ /**
     /**
+     * @inheritDoc
+     */
+    sort(): void;
+    /**
+     * @inheritDoc
+     */
+    sort(comp: (x: T, y: T) => boolean): void;
+    /**
+     * @inheritDoc
+     */
+    reverse(): void;
+    /**
      * @inheritdoc
@@ -25,0 +34,0 @@ */

lib/linear/List.js

@@ -30,10 +30,14 @@ "use strict";
     // using super.constructor;
-    /**
-     * @hidden
-     */
-    List.prototype._Create_iterator = function (prev, next, val) {
-        return new Iterator(this["ptr_"], prev, next, val);
+    List.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        _super.prototype.clear.call(this);
+        this._Notify_erase(first, last);
     };
-    /* ---------------------------------------------------------
+    /* =========================================================
         ELEMENTS I/O
+            - INSERT & ERASE
+            - ALGORITHMS
+    ============================================================
+        INSERT & ERASE
     --------------------------------------------------------- */
@@ -58,2 +62,14 @@ /**
     };
+    List.prototype.sort = function (comp) {
+        if (comp === void 0) { comp = std.less; }
+        _super.prototype.sort.call(this, comp);
+        this.refresh();
+    };
+    /**
+     * @inheritDoc
+     */
+    List.prototype.reverse = function () {
+        _super.prototype.reverse.call(this);
+        this.refresh();
+    };
     List.prototype.refresh = function (first, last) {
@@ -74,3 +90,4 @@ if (first === void 0) { first = null; }
     List.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -119,23 +136,22 @@ /**
 exports.List = List;
-/**
- * @hidden
- */
-var Iterator = /** @class */ (function (_super) {
-    __extends(Iterator, _super);
-    function Iterator() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(Iterator.prototype, "value", {
-        get: function () {
-            return this["value_"];
-        },
-        set: function (val) {
-            this["value_"] = val;
+Object.defineProperty(std.List.Iterator.prototype, "value", {
+    get: function () {
+        return this.value_;
+    },
+    set: function (val) {
+        this.value_ = val;
+        if (this.source() instanceof List)
             this.source().refresh(this);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return Iterator;
-}(std.List.Iterator));
+    },
+    enumerable: true,
+    configurable: true
+});
+var old_swap = std.List.prototype.swap;
+std.List.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof List)
+        this.refresh();
+    if (obj instanceof List)
+        obj.refresh();
+};
 //# sourceMappingURL=List.js.map

lib/linear/Vector.d.ts

@@ -9,2 +9,3 @@ import * as std from "tstl";
     private dispatcher_;
+    clear(): void;
     /**
@@ -11,0 +12,0 @@ * @inheritdoc

lib/linear/Vector.js

@@ -46,2 +46,12 @@ "use strict";
     }
+    /* ---------------------------------------------------------
+        CONSTRUCTORS
+    --------------------------------------------------------- */
+    // using super.constructor;
+    Vector.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        this._Notify_erase(first, last);
+        _super.prototype.clear.call(this);
+    };
     /* =========================================================
@@ -134,3 +144,4 @@ ELEMENTS I/O
     Vector.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -179,2 +190,10 @@ /**
 exports.Vector = Vector;
+var old_swap = std.Vector.prototype.swap;
+std.Vector.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof Vector)
+        this.refresh();
+    if (obj instanceof Vector)
+        obj.refresh();
+};
 //# sourceMappingURL=Vector.js.map

lib/linear/VectorBoolean.d.ts

@@ -9,2 +9,3 @@ import * as std from "tstl";
     private dispatcher_;
+    clear(): void;
     /**
@@ -11,0 +12,0 @@ * @inheritdoc

lib/linear/VectorBoolean.js

@@ -26,2 +26,12 @@ "use strict";
     }
+    /* ---------------------------------------------------------
+        CONSTRUCTORS
+    --------------------------------------------------------- */
+    // using super.constructor;
+    VectorBoolean.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        this._Notify_erase(first, last);
+        _super.prototype.clear.call(this);
+    };
     /* =========================================================
@@ -116,3 +126,4 @@ ELEMENTS I/O
     VectorBoolean.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -161,2 +172,10 @@ /**
 exports.VectorBoolean = VectorBoolean;
+var old_swap = std.VectorBoolean.prototype.swap;
+std.VectorBoolean.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof VectorBoolean)
+        this.refresh();
+    if (obj instanceof VectorBoolean)
+        obj.refresh();
+};
 //# sourceMappingURL=VectorBoolean.js.map

lib/maps/HashMap.d.ts

 import * as std from "tstl";
 import { ICollection } from "../basic/ICollection";
 import { CollectionEvent } from "../basic/CollectionEvent";
+import "./internal";
 export declare class HashMap<Key, T> extends std.HashMap<Key, T> implements ICollection<std.Entry<Key, T>, std.HashMap<Key, T>, std.HashMap.Iterator<Key, T>, std.HashMap.ReverseIterator<Key, T>> {
@@ -9,2 +10,3 @@ /**
     private dispatcher_;
+    clear(): void;
     /**
@@ -11,0 +13,0 @@ * @hidden

lib/maps/HashMap.js

@@ -16,2 +16,3 @@ "use strict";
 var EventDispatcher_1 = require("../basic/EventDispatcher");
+require("./internal");
 var HashMap = /** @class */ (function (_super) {
@@ -28,2 +29,12 @@ __extends(HashMap, _super);
     /* ---------------------------------------------------------
+        CONSTRUCTORS
+    --------------------------------------------------------- */
+    // using super.constructor;
+    HashMap.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        _super.prototype.clear.call(this);
+        this.dispatchEvent(new CollectionEvent_1.CollectionEvent("erase", first, last));
+    };
+    /* ---------------------------------------------------------
         ELEMENTS I/O
@@ -56,3 +67,4 @@ --------------------------------------------------------- */
     HashMap.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -100,2 +112,10 @@ HashMap.prototype.refresh = function (first, last) {
 exports.HashMap = HashMap;
+var old_swap = std.HashMap.prototype.swap;
+std.HashMap.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof HashMap)
+        this.refresh();
+    if (obj instanceof HashMap)
+        obj.refresh();
+};
 //# sourceMappingURL=HashMap.js.map

lib/maps/HashMultiMap.d.ts

 import * as std from "tstl";
 import { ICollection } from "../basic/ICollection";
 import { CollectionEvent } from "../basic/CollectionEvent";
+import "./internal";
 export declare class HashMultiMap<Key, T> extends std.HashMultiMap<Key, T> implements ICollection<std.Entry<Key, T>, std.HashMultiMap<Key, T>, std.HashMultiMap.Iterator<Key, T>, std.HashMultiMap.ReverseIterator<Key, T>> {
@@ -9,2 +10,3 @@ /**
     private dispatcher_;
+    clear(): void;
     /**
@@ -11,0 +13,0 @@ * @hidden

lib/maps/HashMultiMap.js

@@ -16,2 +16,3 @@ "use strict";
 var EventDispatcher_1 = require("../basic/EventDispatcher");
+require("./internal");
 var HashMultiMap = /** @class */ (function (_super) {
@@ -28,2 +29,12 @@ __extends(HashMultiMap, _super);
     /* ---------------------------------------------------------
+        CONSTRUCTORS
+    --------------------------------------------------------- */
+    // using super.constructor;
+    HashMultiMap.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        _super.prototype.clear.call(this);
+        this.dispatchEvent(new CollectionEvent_1.CollectionEvent("erase", first, last));
+    };
+    /* ---------------------------------------------------------
         ELEMENTS I/O
@@ -56,3 +67,4 @@ --------------------------------------------------------- */
     HashMultiMap.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -100,2 +112,10 @@ HashMultiMap.prototype.refresh = function (first, last) {
 exports.HashMultiMap = HashMultiMap;
+var old_swap = std.HashMultiMap.prototype.swap;
+std.HashMultiMap.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof HashMultiMap)
+        this.refresh();
+    if (obj instanceof HashMultiMap)
+        obj.refresh();
+};
 //# sourceMappingURL=HashMultiMap.js.map

lib/maps/TreeMap.d.ts

 import * as std from "tstl";
 import { ICollection } from "../basic/ICollection";
 import { CollectionEvent } from "../basic/CollectionEvent";
+import "./internal";
 export declare class TreeMap<Key, T> extends std.TreeMap<Key, T> implements ICollection<std.Entry<Key, T>, std.TreeMap<Key, T>, std.TreeMap.Iterator<Key, T>, std.TreeMap.ReverseIterator<Key, T>> {
@@ -9,2 +10,3 @@ /**
     private dispatcher_;
+    clear(): void;
     /**
@@ -11,0 +13,0 @@ * @hidden

lib/maps/TreeMap.js

@@ -16,2 +16,3 @@ "use strict";
 var EventDispatcher_1 = require("../basic/EventDispatcher");
+require("./internal");
 var TreeMap = /** @class */ (function (_super) {
@@ -28,2 +29,12 @@ __extends(TreeMap, _super);
     /* ---------------------------------------------------------
+        CONSTRUCTORS
+    --------------------------------------------------------- */
+    // using super.constructor;
+    TreeMap.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        _super.prototype.clear.call(this);
+        this.dispatchEvent(new CollectionEvent_1.CollectionEvent("erase", first, last));
+    };
+    /* ---------------------------------------------------------
         ELEMENTS I/O
@@ -56,3 +67,4 @@ --------------------------------------------------------- */
     TreeMap.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -100,2 +112,10 @@ TreeMap.prototype.refresh = function (first, last) {
 exports.TreeMap = TreeMap;
+var old_swap = std.TreeMap.prototype.swap;
+std.TreeMap.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof TreeMap)
+        this.refresh();
+    if (obj instanceof TreeMap)
+        obj.refresh();
+};
 //# sourceMappingURL=TreeMap.js.map

lib/maps/TreeMultiMap.d.ts

 import * as std from "tstl";
 import { ICollection } from "../basic/ICollection";
 import { CollectionEvent } from "../basic/CollectionEvent";
+import "./internal";
 export declare class TreeMultiMap<Key, T> extends std.TreeMultiMap<Key, T> implements ICollection<std.Entry<Key, T>, std.TreeMultiMap<Key, T>, std.TreeMultiMap.Iterator<Key, T>, std.TreeMultiMap.ReverseIterator<Key, T>> {
@@ -9,2 +10,3 @@ /**
     private dispatcher_;
+    clear(): void;
     /**
@@ -11,0 +13,0 @@ * @hidden

lib/maps/TreeMultiMap.js

@@ -16,2 +16,3 @@ "use strict";
 var EventDispatcher_1 = require("../basic/EventDispatcher");
+require("./internal");
 var TreeMultiMap = /** @class */ (function (_super) {
@@ -28,2 +29,12 @@ __extends(TreeMultiMap, _super);
     /* ---------------------------------------------------------
+        CONSTRUCTORS
+    --------------------------------------------------------- */
+    // using super.constructor;
+    TreeMultiMap.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        _super.prototype.clear.call(this);
+        this.dispatchEvent(new CollectionEvent_1.CollectionEvent("erase", first, last));
+    };
+    /* ---------------------------------------------------------
         ELEMENTS I/O
@@ -56,3 +67,4 @@ --------------------------------------------------------- */
     TreeMultiMap.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -100,2 +112,10 @@ TreeMultiMap.prototype.refresh = function (first, last) {
 exports.TreeMultiMap = TreeMultiMap;
+var old_swap = std.TreeMultiMap.prototype.swap;
+std.TreeMultiMap.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof TreeMultiMap)
+        this.refresh();
+    if (obj instanceof TreeMultiMap)
+        obj.refresh();
+};
 //# sourceMappingURL=TreeMultiMap.js.map

lib/sets/HashMultiSet.d.ts

@@ -9,2 +9,3 @@ import * as std from "tstl";
     private dispatcher_;
+    clear(): void;
     /**
@@ -11,0 +12,0 @@ * @hidden

lib/sets/HashMultiSet.js

@@ -27,2 +27,12 @@ "use strict";
     /* ---------------------------------------------------------
+        CONSTRUCTORS
+    --------------------------------------------------------- */
+    // using super.constructor
+    HashMultiSet.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        _super.prototype.clear.call(this);
+        this.dispatchEvent(new CollectionEvent_1.CollectionEvent("erase", first, last));
+    };
+    /* ---------------------------------------------------------
         ELEMENTS I/O
@@ -55,3 +65,4 @@ --------------------------------------------------------- */
     HashMultiSet.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -99,2 +110,10 @@ HashMultiSet.prototype.refresh = function (first, last) {
 exports.HashMultiSet = HashMultiSet;
+var old_swap = std.HashMultiSet.prototype.swap;
+std.HashMultiSet.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof HashMultiSet)
+        this.refresh();
+    if (obj instanceof HashMultiSet)
+        obj.refresh();
+};
 //# sourceMappingURL=HashMultiSet.js.map

lib/sets/HashSet.d.ts

@@ -9,2 +9,3 @@ import * as std from "tstl";
     private dispatcher_;
+    clear(): void;
     /**
@@ -11,0 +12,0 @@ * @hidden

lib/sets/HashSet.js

@@ -27,2 +27,12 @@ "use strict";
     /* ---------------------------------------------------------
+        CONSTRUCTORS
+    --------------------------------------------------------- */
+    // using super.constructor
+    HashSet.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        _super.prototype.clear.call(this);
+        this.dispatchEvent(new CollectionEvent_1.CollectionEvent("erase", first, last));
+    };
+    /* ---------------------------------------------------------
         ELEMENTS I/O
@@ -55,3 +65,4 @@ --------------------------------------------------------- */
     HashSet.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -99,2 +110,10 @@ HashSet.prototype.refresh = function (first, last) {
 exports.HashSet = HashSet;
+var old_swap = std.HashSet.prototype.swap;
+std.HashSet.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof HashSet)
+        this.refresh();
+    if (obj instanceof HashSet)
+        obj.refresh();
+};
 //# sourceMappingURL=HashSet.js.map

lib/sets/TreeMultiSet.d.ts

@@ -9,2 +9,3 @@ import * as std from "tstl";
     private dispatcher_;
+    clear(): void;
     /**
@@ -11,0 +12,0 @@ * @hidden

lib/sets/TreeMultiSet.js

@@ -27,2 +27,12 @@ "use strict";
     /* ---------------------------------------------------------
+        CONSTRUCTORS
+    --------------------------------------------------------- */
+    // using super.constructor
+    TreeMultiSet.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        _super.prototype.clear.call(this);
+        this.dispatchEvent(new CollectionEvent_1.CollectionEvent("erase", first, last));
+    };
+    /* ---------------------------------------------------------
         ELEMENTS I/O
@@ -55,3 +65,4 @@ --------------------------------------------------------- */
     TreeMultiSet.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -99,2 +110,10 @@ TreeMultiSet.prototype.refresh = function (first, last) {
 exports.TreeMultiSet = TreeMultiSet;
+var old_swap = std.TreeMultiSet.prototype.swap;
+std.TreeMultiSet.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof TreeMultiSet)
+        this.refresh();
+    if (obj instanceof TreeMultiSet)
+        obj.refresh();
+};
 //# sourceMappingURL=TreeMultiSet.js.map

lib/sets/TreeSet.d.ts

@@ -9,2 +9,3 @@ import * as std from "tstl";
     private dispatcher_;
+    clear(): void;
     /**
@@ -11,0 +12,0 @@ * @hidden

lib/sets/TreeSet.js

@@ -27,2 +27,12 @@ "use strict";
     /* ---------------------------------------------------------
+        CONSTRUCTORS
+    --------------------------------------------------------- */
+    // using super.constructor
+    TreeSet.prototype.clear = function () {
+        var first = this.begin();
+        var last = this.end();
+        _super.prototype.clear.call(this);
+        this.dispatchEvent(new CollectionEvent_1.CollectionEvent("erase", first, last));
+    };
+    /* ---------------------------------------------------------
         ELEMENTS I/O
@@ -55,3 +65,4 @@ --------------------------------------------------------- */
     TreeSet.prototype.dispatchEvent = function (event) {
-        this.dispatcher_.dispatchEvent(event);
+        if (this.dispatcher_)
+            this.dispatcher_.dispatchEvent(event);
     };
@@ -99,2 +110,10 @@ TreeSet.prototype.refresh = function (first, last) {
 exports.TreeSet = TreeSet;
+var old_swap = std.TreeSet.prototype.swap;
+std.TreeSet.prototype.swap = function (obj) {
+    old_swap.call(this, obj);
+    if (this instanceof TreeSet)
+        this.refresh();
+    if (obj instanceof TreeSet)
+        obj.refresh();
+};
 //# sourceMappingURL=TreeSet.js.map

lib/tests.d.ts

 export {};

lib/tests.js

@@ -0,0 +0,0 @@ "use strict";

lib/tests/linear.d.ts

 export declare function test_linear_containers(): void;

lib/tests/linear.js

@@ -0,0 +0,0 @@ "use strict";

package.json

@@ -9,11 +9,11 @@ {
   },
-  "version": "0.0.1",
+  "version": "0.0.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "scripts": {
-    "build": "tsc && node lib/tests",
+    "build": "node build/template && tsc && node lib/tests",
     "test": "node lib/tests"
   },
   "dependencies": {
-    "tstl": "x.x.x"
+    "tstl": ">= 1.7.5"
   },
@@ -20,0 +20,0 @@ "homepage": "https://github.com/samchon/econ",

README.md

@@ -0,0 +0,0 @@ # **E**vent **Con**tainers

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Wildcard dependency

Quality

Package has a dependency with a floating version range. This can cause issues if the dependency publishes a new major version.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

115486

increased by11.42%

Number of package files

46

increased by4.55%

Lines of code

2749

increased by10.05%

Number of medium quality alerts

1

decreased by-50%

Dependency changes

• Updatedtstl@>= 1.7.5