workspace: use esnext set operations

packages/hydrooj/src/handler/contest.ts

@@ -88,7 +88,7 @@ export class ContestDetailBaseHandler extends Handler {
         ]);
         if (this.tdoc.assign?.length && !this.user.own(this.tdoc) && !this.user.hasPerm(PERM.PERM_VIEW_HIDDEN_CONTEST)) {
             const groups = await user.listGroup(domainId, this.user._id);
-            if (!Set.intersection(this.tdoc.assign, groups.map((i) => i.name)).size) {
+            if (!new Set(this.tdoc.assign).intersection(new Set(groups.map((i) => i.name))).size) {
                 throw new NotAssignedError('contest', tid);
             }
         }

packages/hydrooj/src/handler/domain.ts

@@ -261,7 +261,7 @@ class DomainRoleHandler extends ManageHandler {
     @requireSudo
     @param('roles', Types.ArrayOf(Types.Role))
     async postDelete(domainId: string, roles: string[]) {
-        if (Set.intersection(roles, ['root', 'default', 'guest']).size > 0) {
+        if (new Set(roles).intersection(new Set(['root', 'default', 'guest'])).size > 0) {
             throw new ValidationError('role', null, 'You cannot delete root, default or guest roles');
         }
         await Promise.all([

packages/hydrooj/src/handler/homework.ts

@@ -84,7 +84,7 @@ class HomeworkDetailHandler extends Handler {
         this.tdoc = await contest.get(domainId, tid);
         if (this.tdoc.rule !== 'homework') throw new ContestNotFoundError(domainId, tid);
         if (this.tdoc.assign?.length && !this.user.own(this.tdoc) && !this.user.hasPerm(PERM.PERM_VIEW_HIDDEN_HOMEWORK)) {
-            if (!Set.intersection(this.tdoc.assign, this.user.group).size) {
+            if (!new Set(this.tdoc.assign).intersection(new Set(this.user.group)).size) {
                 throw new NotAssignedError('homework', this.tdoc.docId);
             }
         }

packages/hydrooj/src/handler/problem.ts

@@ -418,7 +418,7 @@ export class ProblemDetailHandler extends ContestDetailBaseHandler {
                 contest.getRelated(this.args.domainId, this.pdoc.docId),
                 contest.getRelated(this.args.domainId, this.pdoc.docId, 'homework'),
             ])).map((tdocs) => tdocs.filter((tdoc) =>
-                this.user.hasPerm(PERM.PERM_VIEW_HIDDEN_CONTEST) || !tdoc.assign?.length || Set.intersection(tdoc.assign, this.user.group).size,
+                this.user.hasPerm(PERM.PERM_VIEW_HIDDEN_CONTEST) || !tdoc.assign?.length || new Set(tdoc.assign).intersection(new Set(this.user.group)).size,
             ));
         }
     }

packages/hydrooj/src/handler/training.ts

@@ -138,7 +138,7 @@ class TrainingDetailHandler extends Handler {
         for (const node of tdoc.dag) {
             ndict[node._id] = node;
             const totalCount = node.pids.length;
-            const doneCount = Set.intersection(node.pids, donePids).size;
+            const doneCount = new Set(node.pids).intersection(new Set(donePids)).size;
             const nsdoc = {
                 progress: totalCount ? Math.floor(100 * (doneCount / totalCount)) : 100,
                 isDone: training.isDone(node, doneNids, donePids),

packages/hydrooj/src/model/discussion.ts

@@ -313,7 +313,7 @@ export async function getListVnodes(domainId: string, ddocs: any, getHidden = fa
         const vnode = await getVnode(domainId, ddoc.parentType, ddoc.parentId.toString());
         res[ddoc.parentType] ||= {};
         if (!getHidden && vnode.hidden) return;
-        if (vnode.assign?.length && Set.intersection(vnode.assign, assign).size) return;
+        if (vnode.assign?.length && new Set(vnode.assign).intersection(new Set(assign)).size) return;
         res[ddoc.parentType][ddoc.parentId] = vnode;
     }
     await Promise.all(ddocs.map((ddoc) => task(ddoc)));
@@ -325,7 +325,7 @@ export function checkVNodeVisibility(type: number, vnode: any, user: User) {
         if (vnode.hidden && !user.own(vnode) && !user.hasPerm(PERM.PERM_VIEW_PROBLEM_HIDDEN)) return false;
     }
     if ([document.TYPE_CONTEST, document.TYPE_TRAINING].includes(type as any)) {
-        if (!user.own(vnode) && vnode.assign?.length && !Set.intersection(vnode.assign, user.group).size) return false;
+        if (!user.own(vnode) && vnode.assign?.length && !new Set(vnode.assign).intersection(new Set(user.group)).size) return false;
     }
     return true;
 }

packages/hydrooj/src/model/training.ts

@@ -63,30 +63,24 @@ export function getPids(dag: TrainingNode[]) {
 }
 
 export function isDone(node: TrainingNode, doneNids: Set<number> | number[], donePids: Set<number> | number[]) {
-    return (Set.isSuperset(new Set(doneNids), new Set(node.requireNids))
-        && Set.isSuperset(new Set(donePids), new Set(node.pids)));
+    return new Set(doneNids).isSupersetOf(new Set(node.requireNids))
+        && new Set(donePids).isSupersetOf(new Set(node.pids));
 }
 
 export function isProgress(node: TrainingNode, doneNids: Set<number> | number[], donePids: Set<number> | number[], progPids: Set<number> | number[]) {
-    return (Set.isSuperset(new Set(doneNids), new Set(node.requireNids))
-        && !Set.isSuperset(new Set(donePids), new Set(node.pids))
-        && Set.intersection(
-            Set.union(new Set(donePids), new Set(progPids)),
-            new Set(node.pids),
-        ).size);
+    return new Set(doneNids).isSupersetOf(new Set(node.requireNids))
+        && !new Set(donePids).isSupersetOf(new Set(node.pids))
+        && new Set(donePids).union(new Set(progPids)).intersection(new Set(node.pids)).size;
 }
 
 export function isOpen(node: TrainingNode, doneNids: Set<number> | number[], donePids: Set<number> | number[], progPids: Set<number> | number[]) {
-    return (Set.isSuperset(new Set(doneNids), new Set(node.requireNids))
-        && !Set.isSuperset(new Set(donePids), new Set(node.pids))
-        && !Set.intersection(
-            Set.union(new Set(donePids), new Set(progPids)),
-            new Set(node.pids),
-        ).size);
+    return new Set(doneNids).isSupersetOf(new Set(node.requireNids))
+        && !new Set(donePids).isSupersetOf(new Set(node.pids))
+        && !new Set(donePids).union(new Set(progPids)).intersection(new Set(node.pids)).size;
 }
 
 export const isInvalid = (node: TrainingNode, doneNids: Set<number> | number[]) =>
-    !Set.isSuperset(new Set(doneNids), new Set(node.requireNids));
+    !new Set(doneNids).isSupersetOf(new Set(node.requireNids));
 
 export async function count(domainId: string, query: Filter<TrainingDoc>) {
     return await document.count(domainId, document.TYPE_TRAINING, query);