@things-factory/ops-master 10.1.248 → 10.1.249

package/dist-client/pages/master/master-page-base.js

@@ -0,0 +1,657 @@
+import { __decorate, __metadata } from "tslib";
+import '@material/web/icon/icon.js';
+import '@operato/data-grist/ox-grist.js';
+import gql from 'graphql-tag';
+import { css, html } from 'lit';
+import { property, query, state } from 'lit/decorators.js';
+import { DataGrist, getEditor } from '@operato/data-grist';
+import { client } from '@operato/graphql';
+import { i18next, localize } from '@operato/i18n';
+import { notify, openPopup } from '@operato/layout';
+import { p13n } from '@operato/p13n';
+import { PageView } from '@operato/shell';
+import { CommonGristStyles, CommonHeaderStyles, ScrollbarStyles, WorkSurfacePageStyles } from '@operato/styles';
+import { isMobileDevice } from '@operato/utils';
+import { patchesFor, readImportRows } from './import-rows.js';
+import { assignmentChangesIn } from './assignment-fields.js';
+import './applied-when-dialog.js';
+/** 열두 축이 공통으로 갖는 유효 기간 — ISA-95. */
+export const EFFECTIVE = [
+    { name: 'effectiveStart', label: 'effective-start', type: 'date', width: 150 },
+    { name: 'effectiveEnd', label: 'effective-end', type: 'date', width: 150 }
+];
+/** 이름과 설명은 열두 축이 모두 갖는다. 이름은 스크롤해도 남는다. */
+export const IDENTITY = [
+    { name: 'name', label: 'name', type: 'string', width: 160, fixed: true },
+    { name: 'description', label: 'description', type: 'string', width: 200 }
+];
+export class MasterPageBase extends p13n(localize(i18next)(PageView)) {
+    constructor() {
+        super(...arguments);
+        this.active = false;
+        this.mode = isMobileDevice() ? 'CARD' : 'GRID';
+        this.ready = false;
+    }
+    static { this.styles = [
+        /* The work surface frame for a list screen (ADR-0060 decision 8). */
+        WorkSurfacePageStyles,
+        CommonGristStyles,
+        CommonHeaderStyles,
+        ScrollbarStyles,
+        css `
+
+      ox-grist {
+        overflow-y: auto;
+        flex: 1;
+      }
+
+      /*
+       * 헤드룸에는 「어디를 보고 있나」만 남는다. 검색은 타이틀 줄로 올라갔다(configOf 의 search).
+       *
+       * 범위가 없는 화면은 이 칸이 비고, 아래 규칙이 그 줄을 아예 감춘다. 빈 띠를 남기지 않는다.
+       */
+      .header {
+        grid-template-areas: 'scope';
+        grid-template-columns: 1fr;
+      }
+
+      .header:empty {
+        display: none;
+      }
+    `
+    ]; }
+    get context() {
+        return {
+            title: i18next.t(`title.${this.spec.title}`),
+            /*
+             * **파일로 한 번에 올린다.**
+             *
+             * 새 공장을 받으면 기준정보를 통째로 넣어야 한다. 자리 · 인원 · 설비가 각각 수백에서 수천
+             * 줄이고, 화면에서 한 줄씩 넣으면 인원 1000명에 다섯 시간을 타이핑만 한다. 그런데 고객은
+             * 그 자료를 이미 엑셀로 갖고 있다.
+             *
+             * 틀은 플랫폼이 갖고 있다(`@things-factory/import-ui`). 도구막대에 버튼을 달고 파일을
+             * 읽어 줄의 배열로 준다. 우리는 그 줄을 이 화면의 열에 맞추고 저장하기만 한다.
+             *
+             * **이 자리에 두면 마스터 화면 전부가 한꺼번에 된다.** 화면마다 따로 만들면 열넷이 조금씩
+             * 다르게 동작한다.
+             */
+            importable: { handler: this.importHandler.bind(this) },
+            /* 제목 옆의 도움말 아이콘 — 상세한 설명은 그 문서가 갖는다. */
+            help: this.spec.help,
+            /*
+             * 검색은 **페이지 타이틀 줄의 오른쪽 끝**에 둔다.
+             *
+             * 타이틀은 페이지 안의 제목 줄에 선다(ADR-0060 결정 9, 모든 앱이 같다). 그래서 그
+             * 줄은 상단 앱 바가 아니라 페이지의 첫 줄이고, 거기 검색을 두면 거르는 곳과 걸러진 결과가 붙어
+             * 있다 — 전에 상단 바를 마다한 이유가 여기서는 생기지 않는다.
+             *
+             * `ox-page-title-bar` 가 이 값을 받아 타이틀 오른쪽에 그린다. 그래서 헤드룸에는 검색을 두지
+             * 않는다 — 두 벌이 되고, 두 벌은 어긋난다.
+             */
+            search: {
+                handler: (search) => {
+                    this.grist.searchText = search;
+                },
+                value: this.grist?.searchText || ''
+            },
+            actions: [
+                {
+                    title: i18next.t('button.save'),
+                    action: this.save.bind(this),
+                    icon: 'save',
+                    /* 이 화면의 주 동작 — 채운 버튼으로 그려진다. 한 화면에 하나만 둔다. */
+                    emphasis: { raised: true }
+                }
+            ],
+            exportable: {
+                name: i18next.t(`title.${this.spec.title}`),
+                data: () => this.grist.exportRecords()
+            }
+        };
+    }
+    /**
+     * 지금 무엇을 보고 있는가 — 표 바로 위.
+     *
+     * 계층을 드릴다운으로 걷는 화면은 「어디를 보고 있나」를 말해야 한다. 대부분의 화면은 표 하나가 전부라
+     * 범위가 없다 — 그런 화면은 아무것도 그리지 않고, 그 줄이 접힌다.
+     */
+    renderScope() {
+        return html ``;
+    }
+    /**
+     * 화면 골격 — 표 하나와 컬럼 설정.
+     *
+     * 자기 인터페이스가 필요한 화면은 이것을 덮어쓴다. 위치와 정지 사유는 계층이라 표가 아니라 나무여야
+     * 하고, 그때 이 render 를 쓰지 않는다.
+     */
+    render() {
+        return html `
+      <ox-grist
+        .mode=${this.mode}
+        .config=${this.gristConfig}
+        .fetchHandler=${this.fetchHandler.bind(this)}
+        .personalConfigProvider=${this.getPagePreferenceProvider(`ox-grist-${this.spec.key}`)}
+      >
+        <!--
+          자리를 뜻으로 구분한다.
+
+            어디를 보고 있나    빵가루           헤드룸 — 표 바로 위
+            좁히는 것          검색             타이틀 줄 오른쪽 끝
+            저지르는 것         저장 · 삭제       화면 바닥 — 셸이 모든 화면에 같은 자리로 둔다
+            고른 것에 하는 것    선택 후 동작      고른 것 옆
+
+          바닥인 이유는 목록을 위에서 아래로 훑고 줄을 고르고 저지르기 때문이다. 손과 눈이 아래에서
+          끝난다. 전에 동작 바를 헤드룸에도 두었다가 「저장」이 위아래에 하나씩 생겼다(실측: top 150 과
+          top 720).
+        -->
+        <div slot="headroom" class="header">${this.renderScope()}</div>
+
+        <!-- 컬럼 설정 버튼. provider 만 넘겨도 버튼은 안 생긴다. 이 요소를 화면이 놓아야 한다. -->
+        <ox-grist-personalizer slot="setting"></ox-grist-personalizer>
+      </ox-grist>
+    `;
+    }
+    /**
+     * 주소 끝의 이름 조각을 **목록 좁히기**에 쓰나.
+     *
+     * 다른 화면의 참조 칸에서 걸어 들어오면 주소가 `.../ops-master-material-definition/M0161-0003` 이
+     * 된다. 그 조각을 아무도 안 읽으면 106줄짜리 목록 첫 장이 뜨고, 사람은 방금 누른 이름을 다시
+     * 찾아야 한다 — 걸어온 보람이 없다.
+     *
+     * 자리 화면과 제조법 화면은 그 조각을 **파고들기**에 이미 쓰고 있다(그 이름 아래를 보여 준다).
+     * 그 둘은 여기서 빠진다 — 두 뜻이 한 조각에 겹치면 어느 쪽도 제대로 안 된다.
+     */
+    get pathSegmentNarrowsList() {
+        return true;
+    }
+    async pageInitialized() {
+        this.gristConfig = this.configOf();
+        this.ready = true;
+    }
+    /**
+     * 셸은 `(changes, after, before)` 를 넘긴다 — 인수 없는 모양으로 좁히면 주소를 읽어야 하는 화면이
+     * 이것을 덮어쓸 수 없다(`after.resourceId` 와 `before.resourceId` 를 비교하는 자리다).
+     */
+    async pageUpdated(_changes, _after, _before) {
+        if (this.active) {
+            this.grist?.fetch();
+        }
+    }
+    /*
+     * 반환 타입을 밝힌다. 적지 않으면 이 자리의 리터럴이 그대로 타입이 되고, 컬럼 구성을 바꾸는 화면이
+     * 이것을 재정의할 수 없다(로케이션이 실제로 막혔다).
+     */
+    configOf() {
+        return {
+            /*
+             * 빈 목록이 하는 말 — **축마다 다르다.**
+             *
+             * 「아직 아무것도 없습니다」 하나로는 이 화면들이 할 말을 못 한다. 기준정보는 처음 오는
+             * 사람이 가장 먼저 만나는 자리이고, 비어 있는 사람이 묻는 것은 「이게 뭔데 채워야 하나」다.
+             * 그 답은 축마다 다르다 — 인원이 없으면 작업 스테이션에서 사람을 고를 수 없고, 근무 캘린더가
+             * 없으면 가동률이 「모름」이 된다.
+             *
+             * 항목 파일을 고치지 않는다. spec.key 로 용어를 끌어오므로 용어만 더하면 새 축도 따라온다.
+             */
+            emptyNote: {
+                title: i18next.t(`text.master-empty-${this.spec.key}`),
+                description: i18next.t(`text.master-empty-${this.spec.key}-hint`, { defaultValue: '' }) || undefined
+            },
+            list: { fields: ['name', 'description'], details: [] },
+            columns: [
+                /* 이름을 고정하면 그 왼쪽의 거터도 함께 남아야 한다 — 아니면 체크박스가 이름 아래로 밀린다. */
+                { type: 'gutter', gutterName: 'sequence', fixed: true },
+                { type: 'gutter', gutterName: 'row-selector', multiple: true, fixed: true },
+                ...this.spec.columns.map(column => this.columnOf(column))
+            ],
+            /* 새 행을 만들 수 있다 — 마스터를 채우는 것이 이 화면의 일이다. */
+            rows: { appendable: true, selectable: { multiple: true } },
+            sorters: [{ name: 'name', desc: false }]
+        };
+    }
+    columnOf(column) {
+        const header = i18next.t(`field.${column.label}`);
+        const editable = !column.readonly;
+        const fixed = column.fixed;
+        const hidden = column.hidden;
+        switch (column.type) {
+            case 'number':
+                return { type: 'float', name: column.name, header, record: { editable }, sortable: true, width: column.width, fixed, hidden };
+            case 'boolean':
+                return { type: 'boolean', name: column.name, header, record: { editable }, width: column.width, fixed, hidden };
+            case 'date':
+                return { type: 'datetime', name: column.name, header, record: { editable }, sortable: true, width: column.width, fixed, hidden };
+            /*
+             * 목록과 JSON 은 **글자로 고친다.** 전용 편집기를 만들면 축마다 다른 편집기가 생기고, 그 편집기가
+             * 모르는 칸이 들어오면 값이 오류 보고 없이 사라진다. 지금은 있는 그대로 보이고 그대로 고친다.
+             *
+             * 이것은 **자리표시자다.** 화면이 갈라진 지금은 그 축의 화면이 자기 편집기를 가질 수 있다.
+             */
+            case 'select':
+                /*
+                 * **빈 줄이 없으면 되돌릴 수 없다.** 한 번 고르면 「아직 안 정했다」로 못 돌아간다. 비워 둘
+                 * 수 없는 칸이면 화면 쪽에서 `options` 에 빈 값을 안 넣으면 된다.
+                 */
+                return {
+                    type: 'select',
+                    name: column.name,
+                    header,
+                    record: { editable, options: column.options ?? [] },
+                    filter: 'select',
+                    sortable: true,
+                    width: column.width,
+                    fixed,
+                    hidden
+                };
+            case 'reference':
+                /*
+                 * 다른 표에서 골라 온다. 자유 텍스트로 두면 `GUNSAN` 을 `GUNSAM` 이라고 쳐도 저장되고,
+                 * 그 뒤로 그 참조는 어디에서도 안 걸린다 — 화면에는 값이 있는데.
+                 *
+                 * 고르기는 팝업이 하고, 검색은 그 팝업이 갖는다. 그래서 열 자체에는 검색 필터를 안 붙인다.
+                 */
+                return {
+                    type: 'reference',
+                    name: column.name,
+                    header,
+                    /*
+                     * **제목을 여기서 채운다.** 팝업 머리에 글자가 없으면 회색 띠에 검색창만 뜨고, 무엇을
+                     * 고르는 중인지 화면이 말하지 않는다. 편집기 자리에서는 못 채운다 — 그리드가 머리말을
+                     * `{ renderer }` 객체로 바꿔서 넘기기 때문에 거기서는 글자를 볼 수 없다.
+                     *
+                     * 열의 머리말을 그대로 쓴다. 「주 근무 로케이션」을 고르는 팝업의 제목이 「주 근무
+                     * 로케이션」이면 둘이 어긋날 수가 없다.
+                     */
+                    record: { editable, reference: { title: header, ...column.reference } },
+                    filter: 'search',
+                    sortable: true,
+                    width: column.width,
+                    fixed,
+                    hidden
+                };
+            case 'iso-duration':
+                /*
+                 * ISO 8601 기간(`PT30S`)이다. 글자로 고치면 `30s` 나 `PT30` 처럼 커널이 못 읽는 것이
+                 * 오류 보고 없이 저장된다. 전용 편집기가 초로 받아 표기를 만든다.
+                 *
+                 * 이 편집기는 기본 등록에 없다 — `bootstrap.ts` 가 등록한다.
+                 */
+                return { type: 'iso-duration', name: column.name, header, record: { editable }, width: column.width, fixed, hidden };
+            /*
+             * JSON 은 **구조를 아는 편집기로 고친다.** 글자로 고치면 괄호 하나가 빠져도 저장 순간까지
+             * 모르고, 저장되면 그 칸을 읽는 쪽이 통째로 못 읽는다. `json5` 는 팝업에서 문법을 보아 준다.
+             */
+            case 'json':
+                return { type: 'json5', name: column.name, header, record: { editable }, width: column.width, fixed, hidden };
+            /*
+             * 목록은 아직 **글자로 고친다.** 이 칸들은 대개 다른 표의 이름을 담는데(등급 · 공정 · 상위
+             * 등급), 그 표에서 골라 오는 편집기가 아직 없다. 자리표시자다.
+             */
+            /*
+             * ── 여럿을 고르는 참조 ──────────────────────────────────────────────────
+             *
+             * 상위 등급 · 요구 검사 · 공정의 차례처럼 **관계를 여럿 다는 칸**이다. 그리는 것은 목록과
+             * 같고(ops-list), 고치는 것은 참조 팝업이 여럿 고르기로 연다.
+             *
+             * 전에는 이런 칸이 전부 `list` 였다 — 즉 자유 텍스트였다. 그래서 GUNSAN 을 GUNSAM 이라고
+             * 쳐도 저장되고, 그 뒤로 그 참조는 어디에서도 안 걸린다. 열 곳이 그 상태였다
+             * (2026-09-05 · 사용자 지시로 전부 바꿈).
+             */
+            case 'reference-list':
+                return {
+                    type: 'ops-list',
+                    name: column.name,
+                    header,
+                    record: {
+                        editable,
+                        /*
+                         * 편집기는 참조 팝업이 맡는다 — 그리기만 목록 렌더러를 쓴다.
+                         *
+                         * 열 빌더는 `column.type` 으로 편집기를 고르므로(column-builder), 여기서 함수를
+                         * 직접 준다. 문자열을 주면 무시되고 글자 편집기가 붙는다.
+                         */
+                        editor: getEditor('reference'),
+                        /*
+                         * 팝업으로 연다고 밝힌다. 표식(edit_square)의 판단이 열 타입을 보는데, 이 열은
+                         * 그리기를 목록 렌더러로 하려고 타입이 `ops-list` 다 — 그대로 두면 칸 안에서
+                         * 고치는 것으로 표시된다.
+                         */
+                        opensPopup: true,
+                        reference: { title: header, multiple: true, ...column.reference }
+                    },
+                    sortable: true,
+                    width: column.width,
+                    fixed,
+                    hidden
+                };
+            case 'list':
+                /*
+                 * 그리기만 우리 것을 쓰고 고치기는 글자 그대로다(`ops-list` 는 렌더러만 등록한다).
+                 * 기본 글자 렌더러는 배열을 구분 없이 이어 붙인다.
+                 */
+                return { type: 'ops-list', name: column.name, header, record: { editable }, width: column.width, fixed, hidden };
+            default:
+                return {
+                    type: 'string',
+                    name: column.name,
+                    header,
+                    record: { editable },
+                    filter: 'search',
+                    sortable: true,
+                    width: column.width,
+                    fixed,
+                    hidden
+                };
+        }
+    }
+    async fetchHandler({ page = 1, limit = 50, sortings = [], filters = [] }) {
+        const fields = this.spec.columns.map(column => column.name).join('\n');
+        /*
+         * ── 주소 끝의 이름 조각으로 좁힌다 ──────────────────────────────────────
+         *
+         * 다른 화면의 참조 칸에서 걸어 들어오면 주소가 `.../ops-master-material-definition/M0161-0003`
+         * 이 된다. 그 조각을 아무도 안 읽으면 106줄짜리 목록 첫 장이 뜨고, 사람은 방금 누른 이름을 다시
+         * 찾아야 한다 — 걸어온 보람이 없다.
+         *
+         * **그리드의 검색어를 세우는 방식은 안 된다.** 그렇게 해 봤더니 값은 실제로 세워지는데(기억에
+         * 남았다) 그 뒤 그리드가 설정을 복원하면서 지웠다. 훅 자리를 앞뒤로 옮겨도 이기지 못하는
+         * 경합이다. 질의를 만드는 이 자리에서 조건을 얹으면 경합이 없다 — 언제 불려도 같은 답이다.
+         * [확인함] 2026-09-04
+         *
+         * 자리 화면과 제조법 화면은 그 조각을 **파고들기**에 이미 쓰므로 여기서 빠진다.
+         */
+        const segment = this.pathSegmentNarrowsList ? this.lifecycle?.resourceId : undefined;
+        if (segment) {
+            filters = [...filters, { name: 'name', operator: 'eq', value: decodeURIComponent(segment) }];
+        }
+        const response = await client.query({
+            query: gql `
+        query ($filters: [Filter!], $pagination: Pagination, $sortings: [Sorting!]) {
+          ${this.spec.query}(filters: $filters, pagination: $pagination, sortings: $sortings) {
+            items {
+              id
+              ${fields}
+            }
+            total
+          }
+        }
+      `,
+            variables: { filters, pagination: { page, limit }, sortings },
+            fetchPolicy: 'no-cache'
+        });
+        const payload = response.data?.[this.spec.query];
+        const records = (payload?.items ?? []).map((item) => this.spreadJson(item));
+        return { total: payload?.total ?? 0, records };
+    }
+    /**
+     * JSON 칸을 **사람이 고칠 수 있는 글자로 편다.**
+     *
+     * 서버는 구조를 구조로 낸다(`ScalarObject` 로 선언하지만 **스키마에 나가는 이름은 `Object`** 다) — 그것이
+   * 사실이고, 곧 붙을 전용 편집기가 원하는 모양이다.
+     * 그런데 지금 이 그리드의 JSON 칸은 글자 편집기라 객체를 그대로 주면 `[object Object]` 가 된다.
+     * 그래서 **화면에 들어올 때만** 편다. 스키마를 화면 사정에 맞추지 않고, 화면이 자기 몫을 한다.
+     *
+     * 이 옮김은 `packJson` 과 짝이다. 한쪽만 고치면 저장이 오류보고없이 망가진다.
+     */
+    spreadJson(item) {
+        const jsonColumns = this.spec.columns.filter(column => column.type === 'json');
+        if (!jsonColumns.length) {
+            return item;
+        }
+        const spread = { ...item };
+        for (const column of jsonColumns) {
+            const value = spread[column.name];
+            /* 비어 있는 것은 비어 있는 채로 둔다 — `null` 을 `"null"` 로 만들면 지운 것이 값이 된다. */
+            if (value === undefined || value === null || typeof value === 'string') {
+                continue;
+            }
+            spread[column.name] = JSON.stringify(value, null, 0);
+        }
+        return spread;
+    }
+    /**
+     * 저장하기 전에 JSON 칸의 글자를 **구조로 되읽는다.**
+     *
+     * 읽지 못하면 **보내지 않는다.** 그냥 보내면 글자가 통째로 값이 되어, 사람이 적은 구조가 사라진 채로
+     * 저장이 성공했다고 나온다. 어느 행 어느 칸인지 말해 주어야 고칠 수 있다.
+     */
+    packJson(patches) {
+        const jsonColumns = this.spec.columns.filter(column => column.type === 'json');
+        if (!jsonColumns.length) {
+            return { patches, problems: [] };
+        }
+        const problems = [];
+        const packed = patches.map((patch, index) => {
+            const one = { ...patch };
+            for (const column of jsonColumns) {
+                const value = one[column.name];
+                if (typeof value !== 'string') {
+                    /* 손대지 않은 칸은 이미 구조다. 비운 칸은 비운 채로 간다. */
+                    continue;
+                }
+                if (value.trim() === '') {
+                    /* 비운 것은 「없앤다」는 뜻이다. 빈 글자로 보내면 칸의 뜻이 흐려진다. */
+                    one[column.name] = null;
+                    continue;
+                }
+                try {
+                    one[column.name] = JSON.parse(value);
+                }
+                catch (error) {
+                    problems.push(i18next.t('text.json-column-unreadable', {
+                        row: index + 1,
+                        column: i18next.t(`field.${column.label}`),
+                        detail: error.message
+                    }));
+                }
+            }
+            return one;
+        });
+        return { patches: packed, problems };
+    }
+    /**
+     * 파일로 올린 줄들을 이 화면의 마스터로 넣는다.
+     *
+     * ── 오류보고없이 버리지 않는다 ─────────────────────────────────────────────────
+     * 모르는 열 이름, 이름이 없는 줄, 중복된 이름을 **알린다.** 오류보고없이 빼면 사람은 다 올라간 줄 알고,
+     * 빠진 것은 나중에 「그 설비가 왜 없지」로 나타난다.
+     *
+     * ── 하나라도 틀리면 아무것도 안 보낸다 ───────────────────────────────────
+     * 절반만 들어가면 무엇이 들어갔는지 사람이 모른다. 파일을 고쳐 다시 올리는 편이 낫다.
+     *
+     * ── 새로 만들 것과 고칠 것을 이름으로 구분한다 ─────────────────────────────
+     * 서버는 `+`(새로)와 `M`(고침, id 필요)을 나눠 받는다. 그러니 **올리기 전에 그 이름들이 이미
+     * 있는지 물어야 한다.** 안 물으면 같은 이름이 두 벌 생긴다.
+     */
+    async importHandler(records) {
+        if (!records?.length) {
+            notify({ message: i18next.t('text.nothing-to-import'), level: 'info' });
+            return;
+        }
+        const byHeader = this.headerIndex();
+        const reading = readImportRows(records, header => byHeader.get(header));
+        if (reading.problems.length) {
+            /* 열 줄까지만 보인다 — 파일이 통째로 어긋나면 문제도 줄 수만큼 나온다. */
+            notify({ message: reading.problems.slice(0, 10).map(problem => this.sayProblem(problem)).join('\n'), level: 'error' });
+            return;
+        }
+        const existing = await this.idsByName(reading.rows.map(row => String(row.name)));
+        const patches = patchesFor(reading.rows, name => existing.get(name));
+        const packed = this.packJson(patches);
+        if (packed.problems.length) {
+            notify({ message: packed.problems.slice(0, 10).join('\n'), level: 'error' });
+            return;
+        }
+        const response = await client.mutate({
+            mutation: gql `
+        mutation ($patches: [Object!]!) {
+          ${this.spec.mutation}(patches: $patches) {
+            id
+          }
+        }
+      `,
+            variables: { patches: packed.patches }
+        });
+        /*
+         * 이 앱의 클라이언트는 서버가 거절해도 던지지 않고 `errors` 에 담아 준다. 여기서 보지 않으면
+         * 아래의 「올렸다」가 실패한 뒤에도 그대로 뜬다. 사유는 앱의 공통 오류 처리가 이미 띄우므로
+         * 여기서 다시 띄우지 않는다 — 같은 말이 두 번 뜬다.
+         */
+        if (response?.errors?.length) {
+            return;
+        }
+        const made = patches.filter(patch => patch.cuFlag === '+').length;
+        notify({
+            message: i18next.t('text.import-done', { made, changed: patches.length - made }),
+            level: 'info'
+        });
+        this.grist.fetch();
+    }
+    /**
+     * 파일의 머리글을 이 화면의 열 이름으로 바꾼다.
+     *
+     * **두 가지를 다 받는다** — 열 이름 그대로(`homeLocation`)와 화면에 보이는 말(`홈 자리`).
+     * 사람이 이 화면에서 내려받아 고쳐 올리면 머리글이 화면의 말이고, 다른 시스템에서 뽑아 오면
+     * 열 이름이다. 한쪽만 받으면 다른 쪽이 통째로 「모르는 열」이 된다.
+     */
+    /** 무엇이 잘못됐는지를 사람에게 보일 문장으로 바꾼다. 줄 번호는 엑셀에서 보는 그 번호다. */
+    sayProblem(problem) {
+        switch (problem.kind) {
+            case 'unknown-column':
+                return i18next.t('error.import-unknown-column', { line: problem.line, column: problem.column });
+            case 'no-name':
+                return i18next.t('error.import-no-name', { line: problem.line });
+            case 'duplicate-name':
+                return i18next.t('error.import-duplicate-name', { line: problem.line, name: problem.name });
+        }
+    }
+    headerIndex() {
+        const found = new Map();
+        for (const column of this.spec.columns) {
+            found.set(column.name, column.name);
+            found.set(i18next.t(`field.${column.name}`), column.name);
+        }
+        return found;
+    }
+    /** 이 이름들이 이미 있나 — 있으면 그 `id`. 없는 이름은 지도에 없다. */
+    async idsByName(names) {
+        const response = await client.query({
+            query: gql `
+        query ($filters: [Filter!], $pagination: Pagination) {
+          ${this.spec.query}(filters: $filters, pagination: $pagination) {
+            items {
+              id
+              name
+            }
+          }
+        }
+      `,
+            variables: {
+                filters: [{ name: 'name', operator: 'in', value: names }],
+                /* 올린 줄 수만큼만 돌아오면 된다. 기본 50으로 두면 51번째부터 새로 만들어 두 벌이 된다. */
+                pagination: { page: 1, limit: names.length }
+            },
+            fetchPolicy: 'no-cache'
+        });
+        return new Map((response.data?.[this.spec.query]?.items ?? []).map((item) => [item.name, item.id]));
+    }
+    /** 「언제부터」를 묻는다. 사람이 그만두면 `undefined` 이고, 그때는 **아무것도 안 보낸다.** */
+    askAppliedWhen(changes) {
+        return new Promise(resolve => {
+            const popup = openPopup(html `<applied-when-dialog
+          .changes=${changes}
+          .onAnswer=${(answer) => {
+                popup?.close?.();
+                resolve(answer);
+            }}
+          .onCancel=${() => {
+                popup?.close?.();
+                resolve(undefined);
+            }}
+        ></applied-when-dialog>`, { backdrop: true, size: 'medium', title: i18next.t('title.when-does-this-apply') });
+        });
+    }
+    async save() {
+        const patches = this.grist.dirtyRecords;
+        if (!patches?.length) {
+            notify({ message: i18next.t('text.nothing-changed'), level: 'info' });
+            return;
+        }
+        const packed = this.packJson(patches);
+        if (packed.problems.length) {
+            /* 하나도 보내지 않는다. 절반만 저장되면 화면과 저장된 것이 달라진다. */
+            notify({ message: packed.problems.join('\n'), level: 'error' });
+            return;
+        }
+        /*
+         * ── 배정과 선언은 「언제부터」를 묻고 보낸다 ─────────────────────────────
+         *
+         * 자리 배정 · 근무조 선언 · 부모 관계는 가동률 분모를 정한다. 그래서 값만 바꾸는 것이 아니라
+         * **언제부터 그렇게 볼 것인가**를 함께 정해야 하고, 과거를 적으면 지연 기록인지 정정인지까지
+         * 갈라야 한다(§`applied-when-dialog`).
+         *
+         * 안 물어도 저장은 된다 — 그때는 「지금부터」라는 주장이 된다. 다만 **묻지 않으면 사람이 그것을
+         * 주장한 줄 모른다.**
+         */
+        const assignments = assignmentChangesIn(this.spec.axis ?? '', patches);
+        const applied = assignments.length ? await this.askAppliedWhen(assignments) : undefined;
+        /* 그만두었으면 아무것도 안 보낸다 — 절반만 저장되면 화면과 저장된 것이 달라진다. */
+        if (assignments.length && !applied) {
+            return;
+        }
+        const response = await client.mutate({
+            /*
+             * **타입 이름은 `Object` 다.**
+             *
+             * 서버가 `ScalarObject` 라는 이름으로 선언하지만 스키마에 나가는 이름은 `Object` 이고,
+             * `ScalarObject` 로 적으면 「Unknown type」으로 거절된다. 2026-09-01부터 이 자리가 그렇게
+             * 적혀 있어 **모든 기준정보 화면의 저장이 안 됐다.** 화면은 오류를 그대로 보여 주지도
+             * 않았다 — 이 앱의 클라이언트는 서버가 거절해도 던지지 않는다.
+             */
+            mutation: gql `
+        mutation ($patches: [Object!]!, $applied: Object) {
+          ${this.spec.mutation}(patches: $patches, applied: $applied) {
+            id
+            name
+          }
+        }
+      `,
+            variables: { patches: packed.patches, applied }
+        });
+        /*
+         * 이 클라이언트는 서버가 거절해도 던지지 않는다 — 오류는 `response.errors` 에 담겨 온다.
+         * 보지 않으면 저장에 실패해도 화면이 목록을 다시 읽어 「저장된 것처럼」 보인다.
+         * 사유 자체는 앱의 공통 오류 처리가 띄운다.
+         */
+        if (response.errors?.length) {
+            return;
+        }
+        /* 지운 행은 사라지지 않고 유효 기간의 끝이 채워진다. 말해 주지 않으면 저장이 안 된 것으로 읽는다. */
+        if (packed.patches.some((patch) => String(patch.cuFlag).toUpperCase() === '-')) {
+            notify({ message: i18next.t('text.retired-not-deleted'), level: 'info' });
+        }
+        this.grist.fetch();
+    }
+}
+__decorate([
+    property({ type: Boolean }),
+    __metadata("design:type", Boolean)
+], MasterPageBase.prototype, "active", void 0);
+__decorate([
+    property({ type: Object }),
+    __metadata("design:type", Object)
+], MasterPageBase.prototype, "gristConfig", void 0);
+__decorate([
+    property({ type: String }),
+    __metadata("design:type", String)
+], MasterPageBase.prototype, "mode", void 0);
+__decorate([
+    state(),
+    __metadata("design:type", Object)
+], MasterPageBase.prototype, "ready", void 0);
+__decorate([
+    query('ox-grist'),
+    __metadata("design:type", DataGrist)
+], MasterPageBase.prototype, "grist", void 0);
+//# sourceMappingURL=master-page-base.js.map