Possibilité de créer une voie de type "Backlog"

Une voie peut désormais "récolter" toutes les issues qui ne sont pas
déjà sélectionnées par d'autres voies i.e. matérialiser un "backlog".

Voir #22

client/src/store/sagas/kanboards.ts

@@ -2,6 +2,9 @@ import { select, put } from 'redux-saga/effects';
 import { fetchIssues, addLabel, removeLabel } from '../actions/issues';
 import { fetchIssuesSaga } from './issues';
 import { BUILD_KANBOARD_SUCCESS, buildKanboard, BUILD_KANBOARD_FAILURE } from '../actions/kanboards';
+import { Project, Issue } from '../../types/gitea';
+import { Board, BoardLane } from '../../types/board';
+import { KanboardLane, Kanboard, KanboardCard } from '../../types/kanboard';
 
 export function* moveCardSaga(action: any) {
   const { 
@@ -64,21 +67,21 @@ export function* refreshKanboardSaga(action: any) {
   }
 }
 
-function createCards(projects: any[], issues: any, lane: any) {
-  return projects.reduce((laneCards, p) => {
+function createCards(projects: Project[], issues: any, lane: BoardLane, rest: Set<KanboardCard>) {
+  const cards: KanboardCard[] = projects.reduce((laneCards, p) => {
 
     const projectIssues = p in issues.byProject ? issues.byProject[p] : [];
 
-    return projectIssues.reduce((projectCards: any, issue: any) => {
+    return projectIssues.reduce((projectCards: KanboardCard[], issue: any) => {
+      
       const hasLabel = issue.labels.some((l: any) => l.name === lane.issueLabel);
+      const card = getMemoizedKanboardCard(issue.id, issue.title, p, issue);
 
       if (hasLabel) {
-        projectCards.push({
-          id: issue.id,
-          title: issue.title,
-          project: p,
-          issue: issue,
-        });
+        projectCards.push(card);
+        rest.delete(card);
+      } else {
+        rest.add(card);
       }
 
       return projectCards;
@@ -86,22 +89,55 @@ function createCards(projects: any[], issues: any, lane: any) {
     }, laneCards);
 
   }, []);
+
+  return cards;
 }
 
-function createLane(projects: any, issues: any, lane: any, index: any) {
-  return {
-    id: index,
-    title: lane.title,
-    cards: createCards(projects, issues, lane)
-  }
+const kanboardCardMemo: {[key: string]: KanboardCard} = {};
+
+function getMemoizedKanboardCard(id: number, title: string, project: Project, issue: Issue): KanboardCard {
+  const key = `${project.id}-${issue.id}-${id}`;
+  if (kanboardCardMemo.hasOwnProperty(key)) return kanboardCardMemo[key];
+  kanboardCardMemo[key] = { id, title, project, issue };
+  return kanboardCardMemo[key];
 }
 
-function createKanboard(board: any, issues: any) {
+function resetKandboarCardMemo() {
+  Object.keys(kanboardCardMemo).forEach(k => delete kanboardCardMemo[k]);
+}
+
+function createKanboardLanes(board: Board, issues: any): KanboardLane[] {
+  const lanes: KanboardLane[]  = [];
+  const rest = new Set<KanboardCard>();
+  
+  resetKandboarCardMemo();
+
+  board.lanes.forEach((l: BoardLane, i: number) => {
+    const cards = createCards(board.projects, issues, l, rest);
+    lanes.push({
+      id: i,
+      title: l.title,
+      cards,
+    });
+  });
+
+  // Assign remaining issues
+  board.lanes.forEach((l: BoardLane, i: number) => {
+    if (!l.collectRemainingIssues) return;
+    lanes[i].cards.push(...Array.from(rest.values()));
+  });
+
+  resetKandboarCardMemo();
+ 
+  return lanes;
+}
+
+function createKanboard(board: Board, issues: any) {
   if (!board) return null;
 
   const kanboard = {
     id: board.id,
-    lanes: board.lanes.map(createLane.bind(null, board.projects, issues)),
+    lanes: createKanboardLanes(board, issues),
   };
   
   return kanboard;