@things-factory/worklist 10.1.248 → 10.1.250

package/dist-client/pages/todo/approval-pending-list-page.js

@@ -0,0 +1,683 @@
+import { __decorate, __metadata } from "tslib";
+import '@operato/data-grist';
+import '@operato/data-grist/ox-filters-form.js';
+import '@operato/input/ox-input-select-buttons.js';
+import '../../components/work-box-groups.js';
+import gql from 'graphql-tag';
+import { css, html } from 'lit';
+import { customElement, property, query, state } from 'lit/decorators.js';
+import { DataGrist, getRenderer } from '@operato/data-grist';
+import { client } from '@operato/graphql';
+import { countChips, dueSoonChip, importantChip, withChips } from '../../chip-filters.js';
+import { i18next, localize } from '@operato/i18n';
+import { navigate, PageView } from '@operato/shell';
+import { listWithThumbnail } from './list-thumbnail.js';
+import { APPROVAL_GROUPS, countsOnTab, groupAddress, groupAt } from './work-box.js';
+import { CommonGristStyles, CommonHeaderStyles, ScrollbarStyles, WorkSurfacePageStyles } from '@operato/styles';
+import { isMobileDevice } from '@operato/utils';
+import { p13n } from '@operato/p13n';
+import { approvalMarks, dueCell, priorityCell, subjectCell } from '../../activity-cells.js';
+const MIN = 60;
+const HOUR = 60 * MIN;
+const DAY = 24 * HOUR;
+let ApprovalPendingListPage = class ApprovalPendingListPage extends p13n(localize(i18next)(PageView)) {
+    constructor() {
+        super(...arguments);
+        /**
+         * 지금 어느 묶음을 보고 있나.
+         *
+         * ── 왜 한 화면에 세 묶음인가 ─────────────────────────────────────────────
+         * 참조를 별도 화면으로 만들면 **아무도 열지 않는다.** 참조는 안 봐도 아무 일이 안 일어나므로,
+         * 아침에 업무 앱을 열면 「승인 대기」를 보지 「참조」를 따로 열지 않는다. 참조를 만든 이유가 의견을
+         * 듣는 것인데 안 여는 화면에 넣으면 의견이 안 온다.
+         *
+         * 그래서 한 화면에 두고, 완료 이력도 같은 자리에서 다시 찾을 수 있게 한다.
+         *
+         * ── 그렇다고 한 목록에 섞지 않는다 ────────────────────────────────────────
+         * 세 묶음의 물음이 다르다 — 「내가 결정할 것」, 「내가 알아야 할 것」, 「끝난 참조 이력」. 섞으면
+         * 참조가 「내가 승인해야 하나」로 읽히고, 배지에 12가 뜨는데 결정할 것은 3건이 된다.
+         *
+         * ── 주소가 주인이다 ──────────────────────────────────────────────────────
+         * `.../approval-pending-list/reference` 로 붙여 보낼 수 있다. 대상이 바뀌는 것이므로 필터와 달리
+         * 주소에 담는다.
+         */
+        this.group = 'approval';
+        /** 세 묶음의 건수. 탭에 함께 적는다 — 안 눌러도 얼마나 있는지 보여야 한다. */
+        this.counts = {};
+        this.mode = isMobileDevice() ? 'CARD' : 'GRID';
+        /** How many each chip would show under the list's other conditions, counted by the list's own door. */
+        this.chipCounts = new Map();
+    }
+    static { this.styles = [
+        /* The frame owns the page shell; the grist is the content it sizes (ADR-0060 decision 8). */
+        WorkSurfacePageStyles,
+        ScrollbarStyles,
+        CommonGristStyles,
+        CommonHeaderStyles,
+        css `
+      /*
+       * 세로로 쌓는다 — 묶음 고르는 줄이 표 **위**에 서야 한다.
+       *
+       * 방향을 빼면 가로로 배치되어, 그 줄이 표 왼쪽에 세로 띠로 서고 버튼 글자가 세로 가운데에
+       * 떠서 표 밑처럼 보인다. 표도 그 띠만큼 밀려 오른쪽 칸이 잘린다. 전에는 자식이 ox-grist
+       * 하나뿐이라 방향이 드러나지 않았다.
+       */
+      :host {
+        --grid-record-emphasized-background-color: #8b0000;
+        --grid-record-emphasized-color: #ff6b6b;
+ }
+      .header {         grid-template-areas: 'filters actions';
+ }
+      /*
+       * ── 헤드룸의 왼쪽 기준선은 표와 같다 ─────────────────────────────────
+       * CommonHeaderStyles 의 .filters 는 배경과 모서리와 여백을 가진 영역이다. 그 배경이
+       * --md-sys-color-surface 인데 이 제품에서는 바탕색과 같은 값이라, **보이지 않는 영역이
+       * 자리만 차지하고** 검색창을 여백만큼(12px) 안쪽으로 밀었다.
+       *
+       * 실측: 표 왼쪽 끝 212 · 필터 영역 212 · 검색창 224. 화면의 왼쪽 기준선이 둘이 됐다.
+       *
+       * 그 규칙들은 .header 안에 중첩되어 있어(.header .filters) 밑줄 없는 .filters 로는 이길 수
+       * 없다 — 특정도가 0,1,0 대 0,2,0 이다.
+       */
+      .header .filters {
+        padding: 0;
+        background: none;
+        border-radius: 0;
+        gap: 12px;
+      }
+
+      /*
+       * 이 화면에는 항목 필터가 없다 — 검색은 제목줄로 올라갔고 남은 것은 칩뿐이다. 그래도
+       * ox-filters-form 은 폭 0으로 남아 자리를 지키고, 그 뒤에 gap 12px 이 붙어 칩들을 밀어냈다.
+       *
+       * 실측: 표 셀 212 · 필터 영역 212 · 칩 224. 왼쪽 기준선이 다시 둘이 됐다.
+       *
+       * 컴포넌트가 스스로 [empty] 를 달아 주므로 그것으로 접는다. 필터가 생기면 그 표식이 사라져
+       * 다시 나온다.
+       */
+      .header .filters ox-filters-form[empty] {
+        display: none;
+      }
+
+      /*
+       * 세 묶음 — 표 위. 지금 보는 쪽은 밑줄과 굵기로 말하고, 옆에 건수를 적는다.
+       *
+       * 건수를 안 눌러도 보이게 두는 것이 요점이다. 참조에 몇 건이 있는지 모르면 열어 볼 이유가 없다.
+       *
+       * ── 필터 칩보다 무거워야 한다 ─────────────────────────────────────────────
+       * 처음에 13px 맨글자로 두었더니, 바로 아래 「중요·만기·재상신」 칩이 테두리를 가져서 더 세게
+       * 보였다. **보는 대상을 바꾸는 것이 대상을 좁히는 것보다 약해 보였다.** 그래서 글자를 14px 로
+       * 올리고(칩은 13px) 세로 여백을 넓혀 제목 다음 자리를 준다.
+       *
+       * 좌우 여백은 품질 화면 탭에서 베끼지 않는다 — 그 화면은 --spacing-large 라 이 화면의 왼쪽
+       * 기준선 212px(표 셀과 같은 값)을 깨뜨린다. 무게만 같게 하고 기준선은 화면이 정한다.
+       */
+    `
+    ]; }
+    get context() {
+        return { title: i18next.t('title.approval pending list'),
+            /*
+             * 검색의 자리는 **기기가 정한다.**
+             *
+             * PC 에서는 화면 안으로 내린다. 상단 바에 두면 거른 조건과 걸러진 결과가 화면의 위아래 끝으로
+             * 갈라지고, 지금 무엇으로 걸렀는지가 목록 옆에서 보이지 않는다.
+             *
+             * 좁은 화면에서는 상단 바에 그대로 둔다. 헤드룸에 두면 검색창과 필터가 목록을 그만큼 밀어
+             * 내리고, 카드 두 장이 화면 밖으로 나간다. 상단 바는 그 자리를 아끼려고 있는 것이다.
+             *
+             * 이 저장소에는 두 방식이 다 있다 — 헤드룸 50곳, 상단 바 51곳. 정형인 것은 구조
+             * (.header / .filters / .filter)이고 검색의 자리는 화면이 정한다.
+             */
+            /*
+             * 검색은 **페이지 제목 줄의 오른쪽 끝**에 둔다 — 다른 화면들과 같은 자리다.
+             *
+             * 전에는 좁은 화면에서만 여기에 넣고, 넓은 화면에서는 헤드룸의 ox-filters-form 이 검색을
+             * 그렸다. 그래서 같은 앱 안에서 검색 상자의 자리가 화면마다 달랐다.
+             *
+             * 헤드룸에는 좁히는 칩만 남는다. 폼은 without-search 로 남겨 두어, 나중에 어느 칸에
+             * filter 를 달면 그 UI 가 저절로 생긴다(비면 아무것도 그리지 않는다).
+             */
+            search: {
+                handler: (search) => {
+                    this.grist.searchText = search;
+                },
+                value: this.grist?.searchText || ''
+            },
+            filter: { handler: () => {
+                    this.grist.toggleHeadroom();
+                }
+            },
+            help: 'worklist/approval-pending-list-page',
+            actions: [] };
+    }
+    render() {
+        const mode = this.mode || (isMobileDevice() ? 'CARD' : 'GRID');
+        return html `
+      <work-box-groups
+        .groups=${[
+            ['approval', 'label.group-approval', 'text.group-approval-hint'],
+            ['reference', 'label.group-reference', 'text.group-reference-hint'],
+            ['completed', 'label.group-completed', 'text.group-completed-hint']
+        ].map(([key, label, hint]) => ({ key, label, hint, count: countsOnTab(key) ? this.counts[key] : undefined }))}
+        .selected=${this.group}
+        @select=${(e) => this.selectGroup(e.detail)}
+      ></work-box-groups>
+
+      <ox-grist
+        class="page-fill"
+        .mode=${mode}
+        .config=${this.gristConfig}
+        .fetchHandler=${this.fetchHandler.bind(this)}
+        .personalConfigProvider=${this.getPagePreferenceProvider('ox-grist')}
+      >
+        <div slot="headroom" class="header">
+          <div class="filters">
+            <!-- 좁은 화면에서는 상단 바가 검색을 갖는다(위 context 주석 참조). -->
+            <ox-filters-form class="filter" without-search></ox-filters-form>
+            <ox-input-select-buttons
+              .value=${this.filters}
+              .options=${this.counted([
+            importantChip(),
+            dueSoonChip(),
+            { display: i18next.t('label.filter-resubmitted'),
+                value: 'resubmitted'
+            }
+        ])}
+              @change=${(e) => {
+            this.filters = e.currentTarget?.value;
+            this.grist.fetch();
+        }}
+            ></ox-input-select-buttons>
+            <!-- <ox-filters-form class="filter" autofocus without-search></ox-filters-form> -->
+          </div>
+
+        </div>
+
+        <ox-grist-personalizer slot="setting"></ox-grist-personalizer>
+      </ox-grist>
+    `;
+    }
+    /** 주소만 바꾼다 — 목록도 설정도 pageUpdated 가 한 벌로 다시 세운다. */
+    selectGroup(group) {
+        if (this.group === group) {
+            return;
+        }
+        navigate(groupAddress(this.lifecycle?.page, group, APPROVAL_GROUPS));
+    }
+    async syncGroup(key) {
+        const group = groupAt(key, APPROVAL_GROUPS);
+        if (this.group === group && this.gristConfig) {
+            return;
+        }
+        this.group = group;
+        this.applyConfig();
+    }
+    /**
+     * 안 보고 있는 묶음의 건수를 따로 센다 — 한 줄만 받아 `total` 을 읽는다.
+     *
+     * 보고 있는 쪽의 수는 목록 조회가 이미 알려 준다(fetchHandler). 그래서 여기서는 나머지 둘만 묻는다.
+     */
+    async countOther() {
+        const queries = {
+            approval: 'approvalPendingList',
+            reference: 'approvalReferenceList'
+        };
+        const others = Object.keys(queries).filter(group => group !== this.group);
+        const results = await Promise.all(others.map(async (group) => ({
+            group,
+            response: await client.query({
+                query: gql `
+            query ($pagination: Pagination) {
+              responses: ${queries[group]}(pagination: $pagination) {
+                total
+              }
+            }
+          `,
+                variables: { pagination: { page: 1, limit: 1 } },
+                fetchPolicy: 'no-cache'
+            })
+        })));
+        /*
+         * A count we could not fetch is not zero.
+         *
+         * This read `?? 0`, and the client runs with errorPolicy: 'all' — a failed query comes back as
+         * a resolved response carrying `errors`, not a rejection. So any failure drew the other tab as
+         * 「0」, which says "nothing is waiting on you". The render already draws nothing when the count
+         * is undefined, so leaving it unknown is both honest and already handled.
+         */
+        const counts = { ...this.counts };
+        for (const { group, response } of results) {
+            const total = response.errors?.length ? undefined : response.data?.responses?.total;
+            if (typeof total == 'number')
+                counts[group] = total;
+        }
+        this.counts = counts;
+    }
+    async pageInitialized(lifecycle) {
+        /*
+         * 주소가 묶음을 정한다. 주소로 바로 들어온 경우가 여기서 잡힌다 — pageUpdated 가 이 함수보다 먼저
+         * 지나가므로 그것만 믿으면 `/reference` 링크가 결재 묶음을 보여준다.
+         */
+        await this.syncGroup(lifecycle?.resourceId);
+        await this.countOther();
+    }
+    applyConfig() {
+        this.gristConfig = { list: { thumbnail: 'thumbnail',
+                fields: ['name', 'description'],
+                details: ['createdAt', 'due']
+            },
+            /*
+             * 빈 화면이 참조를 가르친다.
+             *
+             * 참조를 처음 누른 사람은 여기서 그 개념을 만난다. 기본 문장 「해당하는 것이 없습니다」는
+             * 참조가 무엇인지 말해 주지 않는다 — 내가 결정해야 하는 것인지, 안 봐도 되는 것인지 모른 채
+             * 화면을 닫는다.
+             *
+             * 그래서 없을 때 그 묶음이 무엇인지 적는다.
+             */
+            emptyNote: this.group === 'reference'
+                ? {
+                    icon: 'visibility',
+                    title: i18next.t('text.no-reference-title'),
+                    description: i18next.t('text.no-reference-description')
+                }
+                : this.group === 'completed'
+                    ? {
+                        icon: 'task_alt',
+                        title: i18next.t('text.no-completed-approval-title'),
+                        description: i18next.t('text.no-completed-approval-description')
+                    }
+                    : {
+                        icon: 'task_alt',
+                        title: i18next.t('text.no-approval-title'),
+                        description: i18next.t('text.no-approval-description')
+                    },
+            /*
+             * ── 승인자가 먼저 묻는 순서대로 둔다 (2026-09-01) ─────────────────────
+             *
+             * 전에는 앞자리를 「열기」 버튼과 **모든 줄이 같은 값인 상태 칸**이 차지했고, 승인자가 가장 먼저
+             * 묻는 「누가 올렸나」는 1200px 밖에 있었다. 실측으로 이름부터 담당까지 폭 합이 1287px 이었고
+             * 보이는 폭은 1150px 이었다.
+             *
+             * 순서를 물음의 순서로 바꾼다 — 무엇을 · 누가 · 언제까지 · 얼마나 급한가.
+             *
+             * ── 「열기」 버튼을 없앤다 ─────────────────────────────────────────────
+             * 줄을 누르면 이미 열린다(아래 rows.handlers.click). 같은 일을 하는 버튼이 줄마다 72px 을
+             * 차지하고 있었다.
+             *
+             * 다만 그 버튼의 아이콘이 신호를 하나 들고 있었다 — `comment` 가 있으면 `label`, 없으면
+             * `new_label`. **승인자가 보다가 메모를 남기고 미뤄 둔 것**이라는 뜻이다. 버리지 않고 이름 옆에
+             * 말로 적는다. 태그 아이콘 두 개로는 아무도 그 뜻으로 읽지 않는다.
+             *
+             * 열람 여부는 담는 값이 없다 — `ActivityApproval` 에 `readAt` 이 없어서, 열어만 보고 나가면
+             * 흔적이 남지 않는다. 지금 표시하는 것은 「메모를 남겨 뒀나」이지 「열어 봤나」가 아니다.
+             */
+            columns: [
+                { type: 'gutter', gutterName: 'sequence', fixed: true },
+                {
+                    type: 'string',
+                    name: 'name',
+                    fixed: true,
+                    header: i18next.t('field.wl-subject'),
+                    record: {
+                        editable: false,
+                        /*
+                         * 이름과 설명을 한 칸에 둔다. 둘은 함께 읽는 것인데 275px 짜리 칸으로 갈라 두면 눈이
+                         * 오가고, 그 사이를 우선순위·차수가 가로막고 있었다.
+                         */
+                        renderer: subjectCell(approvalMarks)
+                    },
+                    filter: 'search',
+                    sortable: true,
+                    width: 320
+                },
+                {
+                    /*
+                     * 설명은 제목 칸 안에서 두 줄로 보인다(activity-cells 의 subjectCell). 그래서 따로 보일 칸이
+                     * 필요하지 않다.
+                     *
+                     * 그런데 **칸을 없애면 설명으로 검색하는 기능이 함께 사라진다.** searchText 는
+                     * filter: 'search' 를 선언한 컬럼마다 필터를 만들고 hidden 은 보지 않는다
+                     * (data-grist.ts 의 set searchText). 실측으로 확인했다 — 컬럼을 없앤 뒤 설명에만 있는
+                     * 낱말로 검색하면 0건이었다.
+                     *
+                     * 그래서 감춘 칸으로 남겨 검색만 남긴다.
+                     */
+                    type: 'string',
+                    name: 'description',
+                    header: i18next.t('field.description'),
+                    record: { editable: false },
+                    filter: 'search',
+                    hidden: true
+                },
+                {
+                    type: 'resource-object',
+                    name: 'creator',
+                    header: i18next.t('field.wl-drafter'),
+                    record: { editable: false },
+                    sortable: true,
+                    width: 110
+                },
+                {
+                    type: 'resource-object',
+                    name: 'assignee',
+                    header: i18next.t('field.wl-owner'),
+                    record: { editable: false },
+                    width: 110
+                },
+                {
+                    /*
+                     * 기한 한 칸 — 남은 시간이 위, 절대 시각이 아래다.
+                     *
+                     * 전에는 「만기 시간」(180px)과 「남은 시간」(180px)이 따로 있었다. 사람이 묻는 것은 「얼마나
+                     * 남았나」 하나이고, 절대 시각은 그것을 확인할 때만 본다. 두 칸으로 360px 을 쓸 일이 아니다.
+                     */
+                    type: 'string',
+                    name: 'dueAt',
+                    header: i18next.t('field.wl-due'),
+                    record: {
+                        editable: false,
+                        renderer: dueCell(() => this.active)
+                    },
+                    sortable: true,
+                    width: 170
+                },
+                {
+                    type: 'number',
+                    name: 'priority',
+                    header: i18next.t('field.wl-priority'),
+                    record: {
+                        editable: false,
+                        align: 'center',
+                        renderer: priorityCell()
+                    },
+                    width: 80
+                },
+                {
+                    type: 'select',
+                    name: 'state',
+                    header: i18next.t('field.wl-state'),
+                    record: {
+                        editable: false,
+                        options: [
+                            { display: i18next.t('label.activity-state-submitted'), value: 'submitted' },
+                            { display: i18next.t('label.activity-state-escalated'), value: 'escalated' },
+                            { display: i18next.t('label.activity-state-ended'), value: 'ended' }
+                        ]
+                    },
+                    width: 90
+                },
+                {
+                    type: 'number',
+                    name: 'round',
+                    header: i18next.t('field.wl-round'),
+                    record: { editable: false, align: 'right' },
+                    width: 60
+                },
+                {
+                    type: 'datetime',
+                    name: 'createdAt',
+                    header: i18next.t('field.wl-submitted-at'),
+                    record: { editable: false },
+                    sortable: true,
+                    filter: false,
+                    width: 160
+                },
+                {
+                    type: 'datetime',
+                    name: 'updatedAt',
+                    header: i18next.t('field.wl-changed-at'),
+                    record: { editable: false },
+                    sortable: true,
+                    filter: false,
+                    width: 160
+                },
+                {
+                    type: 'string',
+                    name: 'viewSource',
+                    header: i18next.t('field.wl-view-source'),
+                    record: {
+                        editable: false,
+                        renderer: function (value, column, record, rowIndex, field) {
+                            const { viewType, viewSource } = record.activity || {};
+                            var type = viewType !== 'board' ? 'string' : 'board';
+                            return getRenderer(type)(viewSource, column, record, rowIndex, field);
+                        }
+                    },
+                    width: 140,
+                    hidden: true
+                },
+                {
+                    type: 'image',
+                    name: 'thumbnail',
+                    header: i18next.t('field.thumbnail'),
+                    record: { editable: false },
+                    hidden: true,
+                    handlers: {
+                        click: (columns, data, column, record, rowIndex) => {
+                            this.openActivityApproval(record);
+                        }
+                    }
+                }
+            ],
+            rows: { appendable: false,
+                editable: false,
+                handlers: { click: (columns, data, column, record, rowIndex) => {
+                        this.openActivityApproval(record);
+                    }
+                }
+            },
+            /*
+             * 급한 것부터 — 「할 일」 목록과 같은 순서다.
+             *
+             * 최근 변경 내림차순이었다. 받은 편지함으로는 말이 되지만 이 목록의 물음은 「무엇을 먼저
+             * 판단해야 하나」다. 그 정렬에서는 나흘 지난 건이 목록 중간에 묻힌다 — 기안자가 나흘째
+             * 기다리는 동안.
+             *
+             * 두 목록은 같은 성격이다(내가 처리해야 할 것). 순서 기준이 다르면 화면을 옮길 때마다 다른
+             * 순서를 본다.
+             *
+             * 기한이 없는 건은 뒤로 간다 — 서버가 그 자리를 정한다(applyApprovalSortings).
+             */
+            sorters: [
+                { name: 'dueAt',
+                    desc: false
+                }
+            ]
+        };
+        if (this.group === 'reference') {
+            /*
+             * ── 내 참조가 어떤 상태인가 ─────────────────────────────────────────
+             * 이 묶음은 진행 중인 참조만 보인다. 끝난 건은 별도 「완료」 탭에서 결재 이력과 함께 확인한다.
+             *
+             * 닫힘 표시는, 이미 읽어 둔 목록 응답이 새로고침 직전에 도착한 경우를 위한 방어 표시다.
+             */
+            this.gristConfig.columns = [
+                ...this.gristConfig.columns,
+                {
+                    type: 'string',
+                    name: 'myReference',
+                    header: i18next.t('field.my-reference'),
+                    record: {
+                        editable: false,
+                        renderer: (value, column, record) => {
+                            const closed = record?.judgment === 'closed';
+                            const comment = (record?.comment || '').trim();
+                            if (!closed) {
+                                return html `<span class="quiet">${i18next.t('text.reference-open')}</span>`;
+                            }
+                            if (!comment) {
+                                return html `<span class="pill quiet"
+                  ><span class="dot"></span>${i18next.t('text.reference-closed-silent')}</span
+                >`;
+                            }
+                            /*
+                             * 의견은 있는데 시각이 없으면 **언제인지 모른다** — commentedAt 이 생기기 전에 적힌
+                             * 줄이다. 모르는 것을 「결정 전」으로도 「결정 후」로도 적지 않고, 의견만 보인다.
+                             */
+                            const after = record?.commentedAt &&
+                                record?.terminatedAt &&
+                                new Date(record.commentedAt).getTime() > new Date(record.terminatedAt).getTime();
+                            return html `
+                <span class="line">
+                  <span>${comment}</span>
+                  ${after ? html `<span class="pill warn">${i18next.t('text.reference-after-decision')}</span>` : ''}
+                </span>
+              `;
+                        }
+                    },
+                    width: 260
+                }
+            ];
+        }
+        if (this.group === 'completed') {
+            this.gristConfig.columns = [
+                ...this.gristConfig.columns,
+                {
+                    type: 'select',
+                    name: 'participation',
+                    header: i18next.t('field.wl-participation'),
+                    record: {
+                        editable: false,
+                        options: [
+                            { display: i18next.t('label.participation-approval'), value: 'approval' },
+                            { display: i18next.t('label.participation-reference'), value: 'reference' }
+                        ]
+                    },
+                    width: 80
+                }
+            ];
+        }
+    }
+    async pageUpdated(changes, lifecycle, changedBefore) {
+        if (lifecycle?.resourceId !== changedBefore?.resourceId) {
+            await this.syncGroup(lifecycle?.resourceId);
+            await this.countOther();
+        }
+        if (this.active) {
+            this.grist?.fetch();
+        }
+    }
+    /* 읽은 것에 그림이 하나도 없으면 카드마다 빈 그림 칸을 세우지 않는다(§ list-thumbnail.ts). */
+    counted(chips) {
+        return chips.map(chip => ({ ...chip, count: this.chipCounts.get(chip.value) ?? 0 }));
+    }
+    /* The chips' numbers - asked beside the list, on the list's filters before any chip is added. */
+    countChips(filters) {
+        countChips(this.group === 'reference' ? 'approvalReferenceList' : this.group === 'completed' ? 'approvalCompletedList' : 'approvalPendingList', ['important', 'due', 'resubmitted'], filters)
+            .then(counts => (this.chipCounts = counts))
+            .catch(e => console.error(e));
+    }
+    async fetchHandler(options) {
+        const fetched = await this.fetchRows(options);
+        this.gristConfig = listWithThumbnail(this.gristConfig, fetched?.records || []);
+        return fetched;
+    }
+    async fetchRows({ page, limit, sortings = [], filters = [] }) {
+        this.countChips(filters);
+        filters = withChips(filters, this.filters);
+        const response = await client.query({ query: gql `
+        query ($filters: [Filter!], $pagination: Pagination, $sortings: [Sorting!]) {           responses: ${this.group === 'reference' ? 'approvalReferenceList' : this.group === 'completed' ? 'approvalCompletedList' : 'approvalPendingList'}(filters: $filters, pagination: $pagination, sortings: $sortings) {             items {               id
+              round
+              comment
+              commentedAt
+              judgment
+              participation
+              terminatedAt
+              activityThread {                 activityInstance {                   activityId: id
+                  name
+                  description
+                  priority
+                  input
+                  refBy
+                  activityType
+                  viewType
+                  viewSource
+                  thumbnail
+                  updatedAt
+                  createdAt
+                  creator {                     id
+                    name
+ }
+ }
+                state
+                output
+                dueAt
+                assignee {                   id
+                  name
+ }
+                assignedAt
+ }
+              updatedAt
+ }
+            total
+ }
+ }
+      `,
+            variables: { filters,
+                pagination: { page, limit },
+                sortings
+            }
+        });
+        const total = response.data.responses.total || 0;
+        /* 보고 있는 묶음의 수는 이 조회가 알려 준다. 나머지 둘만 따로 센다(countOther). */
+        if (this.group !== 'completed')
+            this.counts = { ...this.counts, [this.group]: total };
+        return { total,
+            records: (response.data.responses.items || []).map(item => {
+                let thread = item.activityThread;
+                return { id: item.id,
+                    state: thread.state,
+                    ...thread.activityInstance,
+                    dueAt: thread.dueAt,
+                    assignee: thread.assignee,
+                    assignedAt: thread.assignedAt,
+                    output: thread.output,
+                    round: item.round,
+                    comment: item.comment,
+                    judgment: item.judgment,
+                    participation: item.participation || 'approval',
+                    commentedAt: item.commentedAt,
+                    terminatedAt: item.terminatedAt,
+                    updatedAt: item.updatedAt
+                };
+            })
+        };
+    }
+    openActivityApproval(activityApproval) {
+        navigate(`activity-approval/${activityApproval.id}?title=${activityApproval.name}`);
+    }
+};
+__decorate([
+    property({ type: Object }),
+    __metadata("design:type", Object)
+], ApprovalPendingListPage.prototype, "gristConfig", void 0);
+__decorate([
+    state(),
+    __metadata("design:type", String)
+], ApprovalPendingListPage.prototype, "group", void 0);
+__decorate([
+    state(),
+    __metadata("design:type", Object)
+], ApprovalPendingListPage.prototype, "counts", void 0);
+__decorate([
+    property({ type: String }),
+    __metadata("design:type", String)
+], ApprovalPendingListPage.prototype, "mode", void 0);
+__decorate([
+    query('ox-grist'),
+    __metadata("design:type", DataGrist)
+], ApprovalPendingListPage.prototype, "grist", void 0);
+__decorate([
+    state(),
+    __metadata("design:type", Array)
+], ApprovalPendingListPage.prototype, "filters", void 0);
+__decorate([
+    state(),
+    __metadata("design:type", Object)
+], ApprovalPendingListPage.prototype, "chipCounts", void 0);
+ApprovalPendingListPage = __decorate([
+    customElement('approval-pending-list-page')
+], ApprovalPendingListPage);
+export { ApprovalPendingListPage };
+//# sourceMappingURL=approval-pending-list-page.js.map