node-relation - npm Package Compare versions

Comparing version 1.0.1 to 1.1.0

dist/NodeRelation.d.ts

@@ -16,6 +16,6 @@ import AdvancedArray from './AdvancedArray';
  * @param group     RelationGroup 인스턴스입니다.
- * @param keys      서로 관련성을 가지는 노드입니다.
+ * @param nodes     서로 관련성을 가지는 노드입니다.
  * @description     서로 관련 있는 노드를 매개변수로 넘겨 릴레이션으로 지정합니다.
  */
-declare function setRelation(group: RelationGroup, ...keys: RelationNode[]): RelationGroup;
+declare function setRelation(group: RelationGroup, ...node: RelationNode[]): RelationGroup;
 /**
@@ -30,27 +30,27 @@ *
  * @param group     RelationGroup 인스턴스입니다.
- * @param u         대상 노드입니다.
- * @description     대상 노드를 포함하고 있는 릴레이션을 반환합니다.
+ * @param node      대상 노드입니다.
+ * @description     대상 노드를 포함하고 있는 릴레이션을 반환합니다. 어떤 릴레이션도 대상 노드를 가지고 있지 않다면 null을 반환합니다.
  */
-declare function getRelation(group: RelationGroup, u: RelationNode): Relation;
+declare function getRelation(group: RelationGroup, node: RelationNode): Relation | null;
 /**
  *
  * @param group     RelationGroup 인스턴스입니다.
- * @param u         대상 노드입니다.
+ * @param node      대상 노드입니다.
  * @description     RelationGroup 인스턴스가 대상 노드를 포함하고 있는지 여부를 반환합니다.
  */
-declare function hasNode(group: RelationGroup, u: RelationNode): boolean;
+declare function hasNode(group: RelationGroup, node: RelationNode): boolean;
 /**
  *
  * @param groups    RelationGroup 인스턴스입니다.
- * @param u         대상 노드입니다.
+ * @param node      대상 노드입니다.
  * @description     릴레이션이 대상 노드를 포함하고 있다면 노드를 삭제하고, 해당 릴레이션을 반환합니다. 어떤 릴레이션도 대상 노드를 가지고 있지 않다면 null을 반환합니다.
  */
-declare function deleteNode(groups: RelationGroup, u: RelationNode): Relation | null;
+declare function deleteNode(groups: RelationGroup, node: RelationNode): Relation | null;
 /**
  *
  * @param groups    RelationGroup 인스턴스입니다.
- * @param u         대상 노드입니다.
+ * @param node      대상 노드입니다.
  * @description     대상 노드를 포함하고 있는 릴레이션을 RelationGroup 인스턴스에서 삭제합니다.
  */
-declare function dropRelation(groups: RelationGroup, u: RelationNode): void;
+declare function dropRelation(groups: RelationGroup, node: RelationNode): void;
 /**
@@ -65,6 +65,6 @@ *
  * @param groups    RelationGroup 인스턴스입니다.
- * @param keys      대상 노드입니다.
- * @description     대상 노드를 모두 포함하고 있는 릴레이션을 반환합니다.
+ * @param nodes     대상 노드입니다.
+ * @description     대상 노드를 모두 포함하고 있는 릴레이션을 반환합니다. 해당되는 릴레이션이 없다면 null을 반환합니다.
  */
-declare function getRelationEvery(groups: RelationGroup, ...keys: RelationNode[]): Relation;
+declare function getRelationEvery(groups: RelationGroup, ...nodes: RelationNode[]): Relation | null;
 export { create, clear, hasNode, getNodes, deleteNode, setRelation, getRelation, getRelationEvery, dropRelation, };

dist/NodeRelation.js

@@ -106,3 +106,3 @@ var __extends = (this && this.__extends) || (function () {
      * @param group     RelationGroup 인스턴스입니다.
-     * @param keys      서로 관련성을 가지는 노드입니다.
+     * @param nodes     서로 관련성을 가지는 노드입니다.
      * @description     서로 관련 있는 노드를 매개변수로 넘겨 릴레이션으로 지정합니다.
@@ -112,15 +112,17 @@ */
         var e_2, _a, e_3, _b, e_4, _c;
-        var keys = [];
+        var node = [];
         for (var _i = 1; _i < arguments.length; _i++) {
-            keys[_i - 1] = arguments[_i];
+            node[_i - 1] = arguments[_i];
         }
         var allKeys = new AdvancedArray_1.default;
-        allKeys.push.apply(allKeys, __spread(keys));
+        allKeys.push.apply(allKeys, __spread(node));
         allKeys.deduplication();
         var relations = new AdvancedArray_1.default;
-        var newReleation = new (Relation.bind.apply(Relation, __spread([void 0], allKeys)))();
+        var newRelation = new (Relation.bind.apply(Relation, __spread([void 0], allKeys)))();
         try {
             for (var allKeys_1 = __values(allKeys), allKeys_1_1 = allKeys_1.next(); !allKeys_1_1.done; allKeys_1_1 = allKeys_1.next()) {
                 var key = allKeys_1_1.value;
-                relations.ensure(getRelation(group, key));
+                var matchedRelation = getRelation(group, key);
+                if (matchedRelation)
+                    relations.ensure(matchedRelation);
             }
@@ -141,3 +143,3 @@ }
                         var relationNode = relation_1_1.value;
-                        newReleation.ensure(relationNode);
+                        newRelation.ensure(relationNode);
                     }
@@ -162,3 +164,3 @@ }
         }
-        group.push(newReleation);
+        group.push(newRelation);
         return group;
@@ -174,7 +176,7 @@ }
         var e_5, _a;
-        var lists = new Relation;
+        var relationNodes = new AdvancedArray_1.default;
         try {
             for (var group_1 = __values(group), group_1_1 = group_1.next(); !group_1_1.done; group_1_1 = group_1.next()) {
                 var relation = group_1_1.value;
-                lists.push.apply(lists, __spread(relation));
+                relationNodes.push.apply(relationNodes, __spread(relation));
             }
@@ -189,3 +191,4 @@ }
         }
-        return __spread(new Set(lists));
+        relationNodes.deduplication();
+        return __spread(relationNodes);
     }
@@ -196,6 +199,6 @@ exports.getNodes = getNodes;
      * @param group     RelationGroup 인스턴스입니다.
-     * @param u         대상 노드입니다.
-     * @description     대상 노드를 포함하고 있는 릴레이션을 반환합니다.
+     * @param node      대상 노드입니다.
+     * @description     대상 노드를 포함하고 있는 릴레이션을 반환합니다. 어떤 릴레이션도 대상 노드를 가지고 있지 않다면 null을 반환합니다.
      */
-    function getRelation(group, u) {
+    function getRelation(group, node) {
         var e_6, _a;
@@ -205,3 +208,3 @@ try {
                 var relation = group_2_1.value;
-                if (relation.has(u))
+                if (relation.has(node))
                     return relation;
@@ -217,3 +220,3 @@ }
         }
-        return new Relation;
+        return null;
     }
@@ -224,7 +227,7 @@ exports.getRelation = getRelation;
      * @param group     RelationGroup 인스턴스입니다.
-     * @param u         대상 노드입니다.
+     * @param node      대상 노드입니다.
      * @description     RelationGroup 인스턴스가 대상 노드를 포함하고 있는지 여부를 반환합니다.
      */
-    function hasNode(group, u) {
-        return !!getRelation(group, u);
+    function hasNode(group, node) {
+        return !!getRelation(group, node);
     }
@@ -235,12 +238,11 @@ exports.hasNode = hasNode;
      * @param groups    RelationGroup 인스턴스입니다.
-     * @param u         대상 노드입니다.
+     * @param node      대상 노드입니다.
      * @description     릴레이션이 대상 노드를 포함하고 있다면 노드를 삭제하고, 해당 릴레이션을 반환합니다. 어떤 릴레이션도 대상 노드를 가지고 있지 않다면 null을 반환합니다.
      */
-    function deleteNode(groups, u) {
-        var t = getRelation(groups, u);
+    function deleteNode(groups, node) {
+        var t = getRelation(groups, node);
         if (!t)
             return null;
         else {
-            var i = t.indexOf(u);
-            t.splice(i, 1);
+            t.delete(node);
             return t;
@@ -253,11 +255,12 @@ }
      * @param groups    RelationGroup 인스턴스입니다.
-     * @param u         대상 노드입니다.
+     * @param node      대상 노드입니다.
      * @description     대상 노드를 포함하고 있는 릴레이션을 RelationGroup 인스턴스에서 삭제합니다.
      */
-    function dropRelation(groups, u) {
+    function dropRelation(groups, node) {
         var i = groups.length;
         while (i--) {
-            var hasKey = groups[i].indexOf(u) !== -1;
-            if (hasKey)
-                groups.splice(i, 1);
+            var relation = groups[i];
+            if (relation.has(node)) {
+                groups.delete(relation);
+            }
         }
@@ -272,3 +275,3 @@ }
     function clear(groups) {
-        groups.splice(0, groups.length);
+        groups.clear();
     }
@@ -279,87 +282,31 @@ exports.clear = clear;
      * @param groups    RelationGroup 인스턴스입니다.
-     * @param keys      대상 노드입니다.
-     * @description     대상 노드를 모두 포함하고 있는 릴레이션을 반환합니다.
+     * @param nodes     대상 노드입니다.
+     * @description     대상 노드를 모두 포함하고 있는 릴레이션을 반환합니다. 해당되는 릴레이션이 없다면 null을 반환합니다.
      */
     function getRelationEvery(groups) {
-        var e_7, _a, e_8, _b;
-        var keys = [];
+        var nodes = [];
         for (var _i = 1; _i < arguments.length; _i++) {
-            keys[_i - 1] = arguments[_i];
+            nodes[_i - 1] = arguments[_i];
         }
-        var result = new Set;
-        try {
-            for (var _c = __values(__spread(keys)), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var u = _d.value;
-                var keys_2 = getRelation(groups, u);
-                if (keys_2.length)
-                    try {
-                        for (var keys_1 = (e_8 = void 0, __values(keys_2)), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
-                            var key = keys_1_1.value;
-                            result.add(key);
-                        }
-                    }
-                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                    finally {
-                        try {
-                            if (keys_1_1 && !keys_1_1.done && (_b = keys_1.return)) _b.call(keys_1);
-                        }
-                        finally { if (e_8) throw e_8.error; }
-                    }
-                else {
-                    result.clear();
-                    break;
+        var matchedRelations = groups.filter(function (relation) {
+            var e_7, _a;
+            try {
+                for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
+                    var node = nodes_1_1.value;
+                    if (!relation.has(node))
+                        return false;
                 }
             }
-        }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_7) throw e_7.error; }
-        }
-        return new (Relation.bind.apply(Relation, __spread([void 0], result)))();
-    }
-    exports.getRelationEvery = getRelationEvery;
-    /**
-     *
-     * @param groups    RelationGroup 인스턴스입니다.
-     * @param keys      대상 노드입니다.
-     * @description     대상 노드 중 한개라도 포함하고 있는 릴레이션의 모든 노드를 릴레이션으로 반환합니다.
-     */
-    function getRelationSome(groups) {
-        var e_9, _a, e_10, _b;
-        var keys = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            keys[_i - 1] = arguments[_i];
-        }
-        var result = new Set;
-        try {
-            for (var _c = __values(__spread(keys)), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var u = _d.value;
-                var keys_4 = getRelation(groups, u);
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
                 try {
-                    for (var keys_3 = (e_10 = void 0, __values(keys_4)), keys_3_1 = keys_3.next(); !keys_3_1.done; keys_3_1 = keys_3.next()) {
-                        var key = keys_3_1.value;
-                        result.add(key);
-                    }
+                    if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
                 }
-                catch (e_10_1) { e_10 = { error: e_10_1 }; }
-                finally {
-                    try {
-                        if (keys_3_1 && !keys_3_1.done && (_b = keys_3.return)) _b.call(keys_3);
-                    }
-                    finally { if (e_10) throw e_10.error; }
-                }
+                finally { if (e_7) throw e_7.error; }
             }
-        }
-        catch (e_9_1) { e_9 = { error: e_9_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_9) throw e_9.error; }
-        }
-        return new (Relation.bind.apply(Relation, __spread([void 0], result)))();
+            return true;
+        });
+        return matchedRelations.pop() || null;
     }
+    exports.getRelationEvery = getRelationEvery;
 });

package.json

 {
   "name": "node-relation",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Manage strings that are related to each other.",
@@ -5,0 +5,0 @@ "main": "dist/NodeRelation.js",

README.md

 # node-relation
 
-This module helps you manage string, numbers, and cymbols as a group.
+This module helps you manage string, numbers, and symbols as a group.
 
@@ -16,2 +16,2 @@ ```
 
-```
+```

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

Improved metrics

Number of lines in readme file

17

increased by6.25%

Worsened metrics

Total package byte prevSize

23378

decreased by-7.26%

Lines of code

505

decreased by-9.5%

No dependency changes