@iyulab/u-board-designer 0.0.0-stage → 0.2.0

package/dist/lib/editing/grid-editing.d.ts

@@ -0,0 +1,19 @@
+import { type CanvasView, type GridCanvasItem, type GridLayout, type GridView, type GridWidgetItem } from '@iyulab/u-board/picture';
+/** What can change on a grid item: its room, and its widget and states or its canvas — whichever it holds. */
+export type GridItemChange = Partial<GridLayout & Pick<GridWidgetItem, 'widget' | 'states'> & Pick<GridCanvasItem, 'canvas'>>;
+/** The item with `id` changed by `change` — a field set to `undefined` is left out, so the document says only what
+ *  differs from the default. */
+export declare function updateGridItem(doc: GridView, id: string, change: GridItemChange): GridView;
+/** Moves the item with `id` to place `to` in the order, the others closing up behind it — one place earlier or later
+ *  (a button, a key), or wherever it is dropped. A place past either end, or the one it is in, leaves the order as it is. */
+export declare function moveGridItem(doc: GridView, id: string, to: number): GridView;
+/** The place of the item with `id` in the order, or -1. */
+export declare function gridItemIndex(doc: GridView, id: string): number;
+/** Removes the item with `id` — and, for a canvas, the triggers that name its nodes along with those naming it. */
+export declare function removeGridItem(doc: GridView, id: string): GridView;
+/** The canvas cell with `id` as a canvas board of its own — its spatial layer with what the board defines once —
+ *  for the canvas editor to edit; `withCellCanvas` writes what it made back. */
+export declare function cellAsCanvas(doc: GridView, id: string): CanvasView | null;
+/** `doc` with the canvas cell `id` made `canvas`: the spatial layer goes to the cell, and what the board defines once
+ *  — its elements, symbols, triggers, appearance and accent — to the board. */
+export declare function withCellCanvas(doc: GridView, id: string, canvas: CanvasView): GridView;

package/dist/lib/editing/grid-editing.js

@@ -0,0 +1,68 @@
+import { isCanvasItem } from '@iyulab/u-board/picture';
+import { triggersWithout, withTriggers } from './trigger-editing.js';
+/** The item with `id` changed by `change` — a field set to `undefined` is left out, so the document says only what
+ *  differs from the default. */
+export function updateGridItem(doc, id, change) {
+    return {
+        ...doc,
+        items: doc.items.map(item => {
+            if (item.id !== id)
+                return item;
+            const next = { ...item, ...change };
+            for (const key of Object.keys(change))
+                if (next[key] === undefined)
+                    delete next[key];
+            return next;
+        }),
+    };
+}
+/** Moves the item with `id` to place `to` in the order, the others closing up behind it — one place earlier or later
+ *  (a button, a key), or wherever it is dropped. A place past either end, or the one it is in, leaves the order as it is. */
+export function moveGridItem(doc, id, to) {
+    const from = doc.items.findIndex(item => item.id === id);
+    if (from < 0 || from === to || to < 0 || to >= doc.items.length)
+        return doc;
+    const items = [...doc.items];
+    const [moved] = items.splice(from, 1);
+    items.splice(to, 0, moved);
+    return { ...doc, items };
+}
+/** The place of the item with `id` in the order, or -1. */
+export function gridItemIndex(doc, id) {
+    return doc.items.findIndex(item => item.id === id);
+}
+/** Removes the item with `id` — and, for a canvas, the triggers that name its nodes along with those naming it. */
+export function removeGridItem(doc, id) {
+    const item = doc.items.find(existing => existing.id === id);
+    const gone = new Set([id, ...(item && isCanvasItem(item) ? item.canvas.nodes.map(node => node.id) : [])]);
+    return withTriggers({ ...doc, items: doc.items.filter(existing => existing.id !== id) }, triggersWithout(doc.triggers, gone));
+}
+/** The canvas cell with `id` as a canvas board of its own — its spatial layer with what the board defines once —
+ *  for the canvas editor to edit; `withCellCanvas` writes what it made back. */
+export function cellAsCanvas(doc, id) {
+    const item = doc.items.find(existing => existing.id === id);
+    if (!item || !isCanvasItem(item))
+        return null;
+    const board = Object.fromEntries(Object.entries(boardOf(doc)).filter(([, value]) => value !== undefined));
+    return { kind: 'canvas', ...item.canvas, ...board };
+}
+/** `doc` with the canvas cell `id` made `canvas`: the spatial layer goes to the cell, and what the board defines once
+ *  — its elements, symbols, triggers, appearance and accent — to the board. */
+export function withCellCanvas(doc, id, canvas) {
+    const { background, nodes, connectors, decorations } = canvas;
+    const cell = { background, nodes, connectors, ...(decorations && { decorations }) };
+    const items = doc.items.map(item => (item.id === id && isCanvasItem(item) ? { ...item, canvas: cell } : item));
+    const next = { ...doc, items };
+    for (const [key, value] of Object.entries(boardOf(canvas))) {
+        if (value === undefined)
+            delete next[key];
+        else
+            next[key] = value;
+    }
+    return next;
+}
+/** What a board defines once, whichever its kind. */
+function boardOf(doc) {
+    const { appearance, accent, elements, symbols, triggers } = doc;
+    return { appearance, accent, elements, symbols, triggers };
+}

package/dist/lib/editing/part-removal.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasView } from '@iyulab/u-board/picture';
+/** The document without these parts — nodes, decorations or connectors by id. A node takes the connectors that join
+ * it along: a line to nothing is not a board. */
+export declare function removeParts(doc: CanvasView, ids: readonly string[]): CanvasView;

package/dist/lib/editing/part-removal.js

@@ -0,0 +1,11 @@
+import { triggersWithout, withTriggers } from './trigger-editing.js';
+/** The document without these parts — nodes, decorations or connectors by id. A node takes the connectors that join
+ * it along: a line to nothing is not a board. */
+export function removeParts(doc, ids) {
+    const gone = new Set(ids);
+    const nodes = doc.nodes.filter(n => !gone.has(n.id));
+    const kept = new Set(nodes.map(n => n.id));
+    const connectors = doc.connectors.filter(c => !gone.has(c.id) && kept.has(c.fromNodeId) && kept.has(c.toNodeId));
+    const decorations = doc.decorations?.filter(d => !gone.has(d.id));
+    return withTriggers({ ...doc, nodes, connectors, ...(decorations && { decorations }) }, triggersWithout(doc.triggers, gone));
+}

package/dist/lib/editing/trigger-editing.d.ts

@@ -0,0 +1,16 @@
+import type { Trigger, ViewDocument } from '@iyulab/u-board/picture';
+/**
+ * A board's triggers once `parts` are gone: a trigger on one of them, or only while one of them is in a state, goes;
+ * an action bringing one into view is taken out, and a trigger left with nothing to do goes too. A trigger naming a
+ * part the board does not place is refused when the board is saved, so removing a part takes these with it.
+ * `undefined` when none is left.
+ */
+export declare function triggersWithout(triggers: readonly Trigger[] | undefined, parts: ReadonlySet<string>): Trigger[] | undefined;
+/** `doc` with `trigger` added at the end of its triggers. */
+export declare function withTrigger<D extends ViewDocument>(doc: D, trigger: Trigger): D;
+/** `doc` with the trigger at `index` replaced by `trigger`. */
+export declare function replaceTrigger<D extends ViewDocument>(doc: D, index: number, trigger: Trigger): D;
+/** `doc` without the trigger at `index` — and without a `triggers` list when that was the last. */
+export declare function removeTrigger<D extends ViewDocument>(doc: D, index: number): D;
+/** `doc` with `triggers` as its list, leaving the field out when there is none. */
+export declare function withTriggers<D extends ViewDocument>(doc: D, triggers: readonly Trigger[] | undefined): D;

package/dist/lib/editing/trigger-editing.js

@@ -0,0 +1,36 @@
+/**
+ * A board's triggers once `parts` are gone: a trigger on one of them, or only while one of them is in a state, goes;
+ * an action bringing one into view is taken out, and a trigger left with nothing to do goes too. A trigger naming a
+ * part the board does not place is refused when the board is saved, so removing a part takes these with it.
+ * `undefined` when none is left.
+ */
+export function triggersWithout(triggers, parts) {
+    if (!triggers)
+        return undefined;
+    const kept = triggers.flatMap(trigger => {
+        if (('node' in trigger.on && parts.has(trigger.on.node)) || (trigger.when && parts.has(trigger.when.node)))
+            return [];
+        const actions = trigger.do.filter(action => !(action.action === 'focus' && parts.has(action.node)));
+        if (actions.length === 0)
+            return [];
+        return [actions.length === trigger.do.length ? trigger : { ...trigger, do: actions }];
+    });
+    return kept.length > 0 ? kept : undefined;
+}
+/** `doc` with `trigger` added at the end of its triggers. */
+export function withTrigger(doc, trigger) {
+    return { ...doc, triggers: [...(doc.triggers ?? []), trigger] };
+}
+/** `doc` with the trigger at `index` replaced by `trigger`. */
+export function replaceTrigger(doc, index, trigger) {
+    return { ...doc, triggers: (doc.triggers ?? []).map((t, i) => (i === index ? trigger : t)) };
+}
+/** `doc` without the trigger at `index` — and without a `triggers` list when that was the last. */
+export function removeTrigger(doc, index) {
+    return withTriggers(doc, (doc.triggers ?? []).filter((_, i) => i !== index));
+}
+/** `doc` with `triggers` as its list, leaving the field out when there is none. */
+export function withTriggers(doc, triggers) {
+    const { triggers: _, ...rest } = doc;
+    return (triggers && triggers.length > 0 ? { ...rest, triggers: [...triggers] } : rest);
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { BoardAuthoring } from './authoring/BoardAuthoring.js';
+export type { BoardAuthoringProps } from './authoring/BoardAuthoring.js';
+export { layoutEditable } from './authoring/board-layout.js';
+export type { AuthoringMode } from './authoring/editor-parts.js';
+export { DEFAULT_DESIGNER_LABELS, resolveDesignerLabels } from './labels.js';
+export type { AuthoringLabels, DesignerLabels } from './labels.js';
+export { KO_DESIGNER_LABELS } from './labels-ko.js';

package/dist/lib/index.js

@@ -0,0 +1,5 @@
+// The authoring tool: a board edited in place, over the viewer's own building blocks.
+export { BoardAuthoring } from './authoring/BoardAuthoring.js';
+export { layoutEditable } from './authoring/board-layout.js';
+export { DEFAULT_DESIGNER_LABELS, resolveDesignerLabels } from './labels.js';
+export { KO_DESIGNER_LABELS } from './labels-ko.js';

package/dist/lib/labels-ko.d.ts

@@ -0,0 +1,4 @@
+import type { AuthoringLabels, DesignerLabels } from './labels.js';
+export declare const KO_AUTHORING_LABELS: AuthoringLabels;
+/** Every label in Korean — what `BoardAuthoring` shows when given `labels: KO_DESIGNER_LABELS`. */
+export declare const KO_DESIGNER_LABELS: DesignerLabels;

package/dist/lib/labels-ko.js

@@ -0,0 +1,270 @@
+import { KO_LABELS } from '@iyulab/u-board/viewer';
+export const KO_AUTHORING_LABELS = {
+    editCanvas: '캔버스 편집',
+    backToGrid: '← 그리드',
+    editGridCell: '칸 그리드 편집',
+    layoutWidth: '배치 폭',
+    layoutWide: '넓게',
+    layoutMedium: '중간',
+    layoutNarrow: '좁게',
+    addConnector: '연결선 추가',
+    connectHint: '연결할 두 노드를 선택하세요(두 번째는 Shift+클릭).',
+    deleteSelected: '삭제',
+    undo: '실행 취소',
+    partAdd: '부품 추가',
+    newPartTitle: '새 부품',
+    redo: '다시 실행',
+    save: '저장',
+    export: '내보내기',
+    import: '가져오기',
+    boardHeading: '보드',
+    setBackground: '배경 이미지',
+    referencePoints: '기준점',
+    referencePointsHint: '이미지의 두 점과 그 점이 나타내는 좌표 — 지도라면 경도·위도, 평면도라면 미터. 그러면 고정한 노드의 자리를 좌표로 읽습니다.',
+    referencePoint: '기준점 {n}',
+    imageX: '이미지 x',
+    imageY: '이미지 y',
+    coordinateX: '좌표 x',
+    coordinateY: '좌표 y',
+    referencePointsApart: '두 점은 이미지에서도 좌표에서도 두 축 모두 달라야 합니다.',
+    referencePointsIncomplete: '여덟 칸을 모두 채우면 저장됩니다 — 그 전까지는 저장된 기준점이 그대로입니다.',
+    clearReferencePoints: '기준점 지우기',
+    referencePointsNeeded: '이전 기준점은 이 이미지에 맞지 않아 지웠습니다. 기준점을 다시 정하세요 — 고정한 노드가 있다면 그 뒤 원래 좌표에 다시 놓을 수 있습니다.',
+    anchorsMoved: '고정한 노드 {count}개가 원래 좌표에서 벗어났습니다.',
+    relocateAnchors: '좌표 그대로 다시 놓기',
+    keepAnchors: '이대로 두기',
+    removeBackground: '배경 제거',
+    appearance: '바탕',
+    appearanceLight: '밝게',
+    appearanceDark: '어둡게',
+    accent: '강조색',
+    accentPlaceholder: '테마 기본',
+    backgroundType: 'PNG, JPEG, WebP, GIF, SVG 이미지를 고르세요.',
+    backgroundTooLarge: '이미지가 {max}보다 큽니다.',
+    backgroundUnreadable: '이미지를 읽지 못했습니다.',
+    mode: '모드',
+    editMode: '편집',
+    viewMode: '보기',
+    editorRegion: '편집기',
+    previewRegion: '보드 보기',
+    selectNode: '노드나 장식을 선택하면 여기서 편집합니다.',
+    itemLayout: '배치',
+    itemSpan: '너비({columns}열 중)',
+    itemSpanMedium: '중간 폭에서 너비({columns}열 중)',
+    itemSpanMediumAuto: '자동 — 전체 폭의 줄 그대로',
+    itemRowSpan: '차지하는 줄 수',
+    itemHeight: '높이(px)',
+    itemHeightAuto: '위젯 기본 높이',
+    canvasHeightAuto: '캔버스 비율대로',
+    moveEarlier: '앞으로',
+    moveLater: '뒤로',
+    duplicateItem: '항목 복제',
+    removeItem: '항목 삭제',
+    multipleSelected: '{count}개 선택됨 — 하나를 선택하면 편집할 수 있습니다.',
+    layoutOnlyHint: '여기서는 부품을 옮기고 크기를 바꾸거나 지울 수 있습니다. 부품을 선택하면 설정을 고칠 수 있습니다.',
+    partHeading: '부품 {id}',
+    linkHeading: '연결선 {from} → {to}',
+    shapeHeading: '도형 {id}',
+    shapeAddBox: '틀 추가',
+    shapeAddText: '글 추가',
+    shapeAddLine: '선 도형 추가',
+    shapePoints: '점(x,y — 빈칸으로)',
+    shapePointsInvalid: '점 둘 이상을 x,y로, 빈칸으로 이어 적으세요: 20,20 220,20.',
+    shapePath: '경로(M · L · C · Q · Z, 절대 좌표)',
+    shapeNewText: '글',
+    shapeLabel: '이름표',
+    shapeText: '글',
+    shapeSize: '글자 크기',
+    shapeWidth: '선 굵기',
+    shapeTone: '톤',
+    linkLabel: '라벨',
+    linkReads: '읽는 항목(상태를 위해)',
+    linkShows: '상태 필드',
+    linkTone: '상태가 없을 때의 톤',
+    linkToneNone: '(대기)',
+    linkRoute: '경로',
+    linkArrow: '화살표',
+    linkDash: '점선',
+    partTitle: '제목',
+    partKind: '종류',
+    partFromPreset: '(프리셋에서)',
+    partOf: '읽는 데이터',
+    partOfNone: '(없음)',
+    partItem: '항목(키)',
+    partItemAll: '모든 항목',
+    partShow: '보일 필드(쉼표로)',
+    partEach: '{data}의 항목마다 하나씩 그려지는 부품입니다.',
+    partOwnOptions: '종류의 옵션',
+    partWidgetOptions: '위젯 옵션',
+    partStructured: '구조로 쓰인 값입니다 — AI 비서나 보드 JSON으로 고칩니다.',
+    boardNotDrawn: '지금 설정으로는 보드를 그릴 수 없습니다 — {reason}. 그릴 수 있었던 마지막 모습을 보여 줍니다.',
+    statusesHeading: '상태',
+    statusTone: '톤',
+    statusLabel: '이름표',
+    statusGlyph: '표시 기호',
+    statusEmphasis: '강조',
+    statusEmphasisNone: '(없음)',
+    statusRemove: '{name} 지우기',
+    statusNew: '새 상태',
+    statusAdd: '상태 추가',
+    dataHeading: '데이터',
+    dataFrom: '원천',
+    dataPath: '요청 경로',
+    dataByRef: '어댑터의 참조로 읽는 데이터입니다 — AI 비서나 보드 JSON으로 고칩니다.',
+    dataList: '응답 속 목록(JSON Pointer)',
+    dataKey: '항목의 키 필드',
+    dataDetails: '읽기 상세',
+    dataWhere: '이 값의 항목만(필드=값, 쉼표로)',
+    dataWhereInvalid: '필드=값을 쉼표로 이어 적으세요: kind=PM10, site=north.',
+    dataTime: '항목을 관측한 시각의 필드',
+    dataAnswerTime: '답 전체를 관측한 시각(JSON Pointer)',
+    dataFresh: '값이 현재로 남는 초',
+    dataZone: '원천이 시각을 쓰는 시간대(IANA)',
+    dataNowDelay: '요청 시각 — 원천이 자료를 갖기까지 초',
+    dataNowStep: '요청 시각 — 원천 자료의 간격 초',
+    dataPivotKey: '이름마다 한 행 — 이름의 필드',
+    dataPivotValue: '이름마다 한 행 — 값의 필드',
+    dataFields: '필드',
+    dataFieldLabel: '이름',
+    dataFieldUnit: '단위',
+    dataFieldDigits: '소수 자리',
+    dataFieldFormat: '서식',
+    dataFieldRemove: '필드 {name} 지우기',
+    dataFieldState: '상태',
+    dataFieldStateRelative: '상태가 시계를 따름(지금부터 그 시각까지의 초에 대한 구간) — 보드 JSON에서 고친다',
+    dataFieldNames: '낱말',
+    mappingNone: '(없음)',
+    mappingRaw: '값이 곧 상태 이름',
+    mappingMap: '값마다',
+    mappingBands: '숫자 띠',
+    mappingFrom: '값 {n}',
+    mappingTo: '이름 {n}',
+    mappingAddRow: '값 추가',
+    mappingOtherwise: '그 밖의 값',
+    mappingBandsText: '이름과 경계를 번갈아(ok, 1, warn, 5, alarm)',
+    mappingBandsInvalid: '이름부터, 이름과 커지는 숫자를 번갈아 적으세요: ok, 1, warn, 5, alarm.',
+    dataFieldNew: '새 필드',
+    dataFieldAdd: '필드 추가',
+    dataLook: '데이터 살펴보기',
+    dataLooking: '읽는 중…',
+    dataFound: '찾은 필드',
+    dataFoundAdd: '{name} 더하기',
+    dataFoundNone: '읽은 것이 없습니다 — 원천과 요청 경로를 확인하세요.',
+    dataRemove: '{name} 지우기',
+    dataNew: '새 데이터',
+    dataAdd: '데이터 추가',
+    widgetType: '위젯 타입',
+    widgetData: '데이터',
+    widgetOptions: '표시',
+    elementProps: '요소 속성',
+    boardElements: '이 보드의 요소',
+    elementsHeading: '요소',
+    addElement: '새 요소',
+    elementName: '이름',
+    elementTemplate: '템플릿',
+    elementScript: '스크립트',
+    elementStyle: 'CSS',
+    elementHeight: '높이(px)',
+    elementScriptPreview: '스크립트 요소는 저장된 보드에서 그려집니다 — 저장하면 보입니다.',
+    removeElement: '요소 삭제',
+    removeElementPlaced: '{count}곳에 배치돼 있습니다 — 먼저 그 위젯을 바꾸거나 지우세요.',
+    elementPropRemove: '{name} 지우기',
+    elementPropNew: '새 prop',
+    elementPropAdd: 'prop 추가',
+    boundField: '바인딩됨',
+    choiceDefault: '기본값',
+    advancedProps: '고급: JSON으로 편집',
+    moreInAdvanced: '고급에서 설정할 옵션: {count}개',
+    noDataSources: '연결된 데이터소스가 없습니다.',
+    propPath: '프롭 경로',
+    choosePropPath: '연결할 값을 고르세요',
+    otherPropPath: '다른 경로…',
+    typedPropPath: '위젯 props 안의 경로',
+    reference: '참조',
+    chooseReference: '참조를 고르세요',
+    path: '요청 경로',
+    pickItemBy: '목록 항목을 고르는 기준',
+    pickItemByPosition: '목록 안 순서(지금처럼)',
+    listItem: '목록 항목',
+    clearListItem: '순서로 고르기',
+    observedAt: '관측 시각',
+    observedAtWhenRead: '읽은 시각',
+    observedAtHint: '응답을 탐색하면 원천이 관측 시각을 적은 필드를 고를 수 있습니다.',
+    timeZone: '원천의 시간대',
+    unknownTimeZone: 'Asia/Seoul이나 UTC 같은 시간대를 입력하세요.',
+    observedAtReads: '읽은 결과: {time} — {age}',
+    observedAtLater: '지금보다 늦은 시각입니다 — 시간대를 확인하세요.',
+    requestTime: '묻는 시각',
+    maxAge: '정상일 때 최대 나이(분)',
+    maxAgeHint: '원천 시각으로 이보다 오래되면 «원천 갱신 늦음»으로 보입니다. 원천에는 이 시간의 8분의 1보다 자주 다시 묻지 않습니다.',
+    invalidMaxAge: '0보다 큰 분 수를 입력하거나 비워 두세요.',
+    keyInPath: '이 경로에 키가 들어 있는 것 같습니다. 보드는 경로를 그대로 저장하고 공유 링크는 그것을 보여 줍니다 — 키는 데이터소스의 인증 방식으로 보내세요.',
+    valuePath: '값 경로',
+    explore: '탐색',
+    wholeResponse: '(전체 응답)',
+    bindingNeedsPropPath: '연결할 프롭 경로를 입력하세요.',
+    bindingNeedsReference: '참조를 고르세요.',
+    valueMapHeading: '값 매핑',
+    mapFrom: '원천 값 {n}',
+    mapTo: '표시 값 {n}',
+    addMapping: '매핑 추가',
+    removeMapping: '매핑 {n} 삭제',
+    rangeMin: '구간 {n} 이상',
+    rangeMax: '구간 {n} 미만',
+    rangeTo: '구간 {n} 표시 값',
+    addRange: '구간 추가',
+    removeRange: '구간 {n} 삭제',
+    rangeInvalid: '구간 {n}: 이상·미만 중 하나 이상을 적고, 둘 다 적으면 미만이 더 커야 합니다.',
+    mapOtherwise: '그 밖의 값',
+    mapOtherwisePlaceholder: '받은 그대로',
+    statesHeading: '상태',
+    statesNeedBinding: '먼저 값을 바인딩하세요 — 부품의 상태는 위젯 바인딩 하나에서 읽습니다.',
+    statesFrom: '읽을 값',
+    statesNone: '상태 없음',
+    statesMapHeading: '값 → 상태',
+    stateForValue: '값 {n}의 상태',
+    stateForRange: '범위 {n}의 상태',
+    statesLooks: '상태별 모양',
+    stateOutline: '테두리 색 — {state}',
+    stateBlink: '깜박임 — {state}',
+    stateHidden: '숨김 — {state}',
+    removeStates: '상태 지우기',
+    triggersHeading: '트리거',
+    triggersOnOpenHeading: '보드가 열릴 때',
+    triggerHeading: '트리거 {n}',
+    triggerEvent: '언제',
+    triggerOnClick: '클릭할 때',
+    triggerOnElement: '요소가 이벤트를 낼 때',
+    triggerOnEnter: '상태에 들어갈 때',
+    triggerOnLeave: '상태에서 나올 때',
+    triggerEventName: '이벤트 이름',
+    triggerState: '상태',
+    triggerOnlyWhen: '어떤 부품이 특정 상태일 때만',
+    triggerEveryItem: '{part}의 모든 항목에',
+    triggerWhenPart: '부품',
+    triggerWhenState: '상태(여럿이면 쉼표로)',
+    triggerAction: '동작 {n}',
+    triggerOpenLink: '링크 열기',
+    triggerFocus: '부품으로 이동',
+    triggerEmit: '페이지에 알리기',
+    triggerGoToBoard: '다른 보드 보기',
+    triggerFocusPart: '이동할 부품 {n}',
+    triggerLinkUrl: '링크 {n}',
+    triggerEmitName: '이벤트 이름 {n}',
+    triggerBoardId: '보드 id {n}',
+    removeTriggerAction: '동작 {n} 지우기',
+    addTriggerAction: '동작 추가',
+    removeTrigger: '트리거 {n} 지우기',
+    addTrigger: '트리거 추가',
+    triggerIncomplete: '칸을 모두 채우세요 — 트리거는 완성되면 저장됩니다.',
+    triggerLinkRefused: '링크는 https:// 주소나 이 설치의 경로(/…)여야 합니다.',
+    mapped: '매핑됨',
+    previewLive: '정상',
+    arrowNone: '없음',
+    arrowEnd: '{to} 쪽으로',
+    arrowStart: '{from} 쪽으로',
+    arrowBoth: '양쪽',
+    arrowFromField: '{field} 값에 따라',
+};
+/** Every label in Korean — what `BoardAuthoring` shows when given `labels: KO_DESIGNER_LABELS`. */
+export const KO_DESIGNER_LABELS = { ...KO_LABELS, ...KO_AUTHORING_LABELS };