@open-mercato/core 0.6.7-develop.6862.1.c11a64ce0a → 0.6.7

package/src/modules/entities/components/EntitySettingsManager.tsx

@@ -1,160 +0,0 @@
-"use client"
-
-import * as React from 'react'
-import { Button } from '@open-mercato/ui/primitives/button'
-import { Checkbox } from '@open-mercato/ui/primitives/checkbox'
-import { Label } from '@open-mercato/ui/primitives/label'
-import { Spinner } from '@open-mercato/ui/primitives/spinner'
-import { flash } from '@open-mercato/ui/backend/FlashMessages'
-import { apiCall, apiCallOrThrow, readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
-import { useT } from '@open-mercato/shared/lib/i18n/context'
-import { ErrorMessage } from '@open-mercato/ui/backend/detail'
-import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
-import { buildOptimisticLockHeader, extractOptimisticLockConflict } from '@open-mercato/ui/backend/utils/optimisticLock'
-import { withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
-
-export function EntitySettingsManager(): React.ReactElement {
-  const t = useT()
-  const [loading, setLoading] = React.useState(true)
-  const [loadError, setLoadError] = React.useState(false)
-  const [saving, setSaving] = React.useState(false)
-  const [restricted, setRestricted] = React.useState(false)
-  const [updatedAt, setUpdatedAt] = React.useState<string | null>(null)
-
-  const { runMutation } = useGuardedMutation({
-    contextId: 'custom-entities-settings',
-  })
-
-  const loadSettings = React.useCallback(async () => {
-    setLoading(true)
-    setLoadError(false)
-    try {
-      const data = await readApiResultOrThrow<{ newEntitiesRestrictedByDefault?: boolean; updatedAt?: string | null }>(
-        '/api/entities/entity-settings',
-        undefined,
-        {
-          errorMessage: t('entities.settings.errors.loadFailed', 'Failed to load settings'),
-        }
-      )
-      setRestricted(data.newEntitiesRestrictedByDefault === true)
-      setUpdatedAt(data.updatedAt ?? null)
-    } catch {
-      setLoadError(true)
-    } finally {
-      setLoading(false)
-    }
-  }, [t])
-
-  React.useEffect(() => {
-    void loadSettings()
-  }, [loadSettings])
-
-  const handleSubmit = async (e: React.FormEvent) => {
-    e.preventDefault()
-    setSaving(true)
-    try {
-      const headers = buildOptimisticLockHeader(updatedAt)
-      await runMutation({
-        operation: () =>
-          withScopedApiRequestHeaders(headers, async () => {
-            const res = await apiCallOrThrow<{ ok: boolean; newEntitiesRestrictedByDefault: boolean; updatedAt: string | null }>(
-              '/api/entities/entity-settings',
-              {
-                method: 'PUT',
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({
-                  newEntitiesRestrictedByDefault: restricted,
-                  expectedUpdatedAt: updatedAt ?? undefined,
-                }),
-              },
-              {
-                errorMessage: t('entities.settings.errors.saveFailed', 'Failed to save settings'),
-              }
-            )
-
-            if (res.ok && res.result) {
-              setUpdatedAt(res.result.updatedAt)
-              flash(t('entities.settings.flash.saved', 'Settings saved'), 'success')
-            }
-            return res
-          }),
-        context: {},
-        mutationPayload: {
-          newEntitiesRestrictedByDefault: restricted,
-        },
-      })
-    } catch (err) {
-      const conflict = extractOptimisticLockConflict(err)
-      if (conflict) {
-        setLoading(true)
-        await loadSettings()
-      } else {
-        flash(t('entities.settings.errors.saveFailed', 'Failed to save settings'), 'error')
-      }
-    } finally {
-      setSaving(false)
-    }
-  }
-
-  if (loading) {
-    return (
-      <div className="flex items-center gap-2 text-sm text-muted-foreground">
-        <Spinner className="h-4 w-4" />
-        <span>{t('entities.userEntities.form.loading', 'Loading…')}</span>
-      </div>
-    )
-  }
-
-  if (loadError) {
-    return (
-      <ErrorMessage
-        label={t('entities.settings.errors.loadFailed', 'Failed to load settings')}
-        action={(
-          <Button type="button" variant="outline" size="sm" onClick={() => void loadSettings()}>
-            {t('common.retry', 'Retry')}
-          </Button>
-        )}
-      />
-    )
-  }
-
-  return (
-    <form onSubmit={(e) => void handleSubmit(e)} className="space-y-6 max-w-2xl">
-      <div className="space-y-1">
-        <h3 className="text-base font-semibold">
-          {t('entities.settings.title', 'Custom Entities')}
-        </h3>
-        <p className="text-sm text-muted-foreground">
-          {t('entities.settings.description', 'Manage global custom entity configurations.')}
-        </p>
-      </div>
-
-      <div className="rounded-lg border bg-card p-4 space-y-4">
-        <div className="flex items-start gap-3">
-          <Checkbox
-            id="newEntitiesRestrictedByDefault"
-            checked={restricted}
-            onCheckedChange={(checked) => setRestricted(checked === true)}
-            disabled={saving}
-            className="mt-1"
-          />
-          <div className="space-y-1">
-            <Label htmlFor="newEntitiesRestrictedByDefault" className="font-medium cursor-pointer">
-              {t('entities.settings.newEntitiesRestrictedByDefault.label', 'Restrict record access by default')}
-            </Label>
-            <p className="text-sm text-muted-foreground">
-              {t('entities.settings.newEntitiesRestrictedByDefault.description', 'Require explicit per-entity permissions for records of newly created custom entities by default.')}
-            </p>
-          </div>
-        </div>
-      </div>
-
-      <div className="flex items-center justify-end gap-3 border-t pt-4">
-        <Button type="submit" disabled={saving}>
-          {saving ? <Spinner className="mr-2 h-4 w-4" /> : null}
-          {t('common.save', 'Save')}
-        </Button>
-      </div>
-    </form>
-  )
-}

package/src/modules/entities/components/RecordListRelationCell.tsx

@@ -1,90 +0,0 @@
-"use client"
-import * as React from 'react'
-import Link from 'next/link'
-import type { CustomFieldDefDto } from '@open-mercato/ui/backend/utils/customFieldDefs'
-import {
-  getRecordListRelationDisplays,
-  resolveRecordListRelationDisplays,
-  type RelationDisplaysByField,
-} from './recordListRelationDisplays'
-
-const RelationDisplaysContext = React.createContext<RelationDisplaysByField>({})
-
-export function RelationDisplaysProvider({
-  displaysByField,
-  children,
-}: {
-  displaysByField: RelationDisplaysByField
-  children: React.ReactNode
-}) {
-  return (
-    <RelationDisplaysContext.Provider value={displaysByField}>
-      {children}
-    </RelationDisplaysContext.Provider>
-  )
-}
-
-export function useRecordListRelationDisplays(
-  definitions: CustomFieldDefDto[],
-  records: Array<Record<string, unknown>>,
-): RelationDisplaysByField {
-  const [displaysByField, setDisplaysByField] = React.useState<RelationDisplaysByField>({})
-
-  React.useEffect(() => {
-    const abortController = new AbortController()
-    setDisplaysByField((current) => (Object.keys(current).length ? {} : current))
-    if (!definitions.length || !records.length) {
-      return () => abortController.abort()
-    }
-
-    void resolveRecordListRelationDisplays(definitions, records, abortController.signal)
-      .then((resolvedDisplays) => {
-        if (!abortController.signal.aborted) setDisplaysByField(resolvedDisplays)
-      })
-      .catch(() => {
-        if (!abortController.signal.aborted) setDisplaysByField({})
-      })
-
-    return () => abortController.abort()
-  }, [definitions, records])
-
-  return displaysByField
-}
-
-export function RelationCell({
-  fieldKey,
-  value,
-  fallbackText,
-}: {
-  fieldKey: string
-  value: unknown
-  fallbackText: string
-}) {
-  const displaysByField = React.useContext(RelationDisplaysContext)
-  const resolvedDisplays = getRecordListRelationDisplays(value, displaysByField[fieldKey])
-  const rawValue = resolvedDisplays.map((display) => display.id).join(', ') || fallbackText
-
-  if (!resolvedDisplays.length) {
-    return <span className="inline-block max-w-60 truncate align-top" title={rawValue}>{rawValue}</span>
-  }
-
-  return (
-    <span className="inline-block max-w-60 truncate align-top" title={rawValue}>
-      {resolvedDisplays.map((display, index) => (
-        <React.Fragment key={`${display.id}-${index}`}>
-          {index > 0 ? ', ' : null}
-          {display.href ? (
-            <Link
-              href={display.href}
-              className="font-medium text-primary underline-offset-2 hover:underline focus-visible:underline"
-              onClick={(event) => event.stopPropagation()}
-              onKeyDown={(event) => event.stopPropagation()}
-            >
-              {display.label}
-            </Link>
-          ) : display.label}
-        </React.Fragment>
-      ))}
-    </span>
-  )
-}

package/src/modules/entities/components/recordListRelationDisplays.ts

@@ -1,109 +0,0 @@
-import type { CustomFieldDefDto } from '@open-mercato/ui/backend/utils/customFieldDefs'
-import {
-  buildRelationHref,
-  collectRelationValueIds,
-  fetchRelationRecordDisplays,
-  parseRelationOptionsMetadata,
-  type RelationOptionsMetadata,
-  type ResolvedValueDisplay,
-} from '@open-mercato/ui/backend/utils/customFieldRelationDisplay'
-
-export type RelationDisplaysByField = Record<string, Record<string, ResolvedValueDisplay>>
-
-type RelationLookup = {
-  optionsUrl: string
-  relation: RelationOptionsMetadata
-  recordIds: Set<string>
-  recordIdsByField: Map<string, Set<string>>
-}
-
-export function resolveRelationOptionsUrl(definition: CustomFieldDefDto): string | null {
-  if (definition.kind !== 'relation') return null
-
-  const configuredUrl = definition.optionsUrl?.trim()
-  if (configuredUrl && parseRelationOptionsMetadata(configuredUrl)) return configuredUrl
-
-  const relatedEntityId = definition.relatedEntityId?.trim()
-  if (!relatedEntityId) return null
-  return `/api/entities/relations/options?entityId=${encodeURIComponent(relatedEntityId)}`
-}
-
-function collectRelationLookups(
-  definitions: CustomFieldDefDto[],
-  records: Array<Record<string, unknown>>,
-): RelationLookup[] {
-  const lookups = new Map<string, RelationLookup>()
-
-  definitions.forEach((definition) => {
-    const optionsUrl = resolveRelationOptionsUrl(definition)
-    if (!optionsUrl) return
-    const relation = parseRelationOptionsMetadata(optionsUrl)
-    if (!relation) return
-
-    const recordIds = new Set(
-      records.flatMap((record) => collectRelationValueIds(record[definition.key])),
-    )
-    if (!recordIds.size) return
-
-    const lookupKey = JSON.stringify([relation.entityId, optionsUrl])
-    const lookup = lookups.get(lookupKey) ?? {
-      optionsUrl,
-      relation,
-      recordIds: new Set<string>(),
-      recordIdsByField: new Map<string, Set<string>>(),
-    }
-    recordIds.forEach((recordId) => lookup.recordIds.add(recordId))
-    lookup.recordIdsByField.set(definition.key, recordIds)
-    lookups.set(lookupKey, lookup)
-  })
-
-  return Array.from(lookups.values())
-}
-
-export async function resolveRecordListRelationDisplays(
-  definitions: CustomFieldDefDto[],
-  records: Array<Record<string, unknown>>,
-  signal?: AbortSignal,
-): Promise<RelationDisplaysByField> {
-  const displaysByField: RelationDisplaysByField = {}
-  const lookups = collectRelationLookups(definitions, records)
-
-  await Promise.all(lookups.map(async (lookup) => {
-    let fetchedDisplays: Record<string, ResolvedValueDisplay> = {}
-    try {
-      fetchedDisplays = await fetchRelationRecordDisplays(
-        lookup.optionsUrl,
-        lookup.relation,
-        Array.from(lookup.recordIds),
-        signal,
-      )
-    } catch {
-      fetchedDisplays = {}
-    }
-
-    if (signal?.aborted) return
-    lookup.recordIdsByField.forEach((recordIds, fieldKey) => {
-      const fieldDisplays: Record<string, ResolvedValueDisplay> = {}
-      recordIds.forEach((recordId) => {
-        fieldDisplays[recordId] = fetchedDisplays[recordId] ?? {
-          label: recordId,
-          href: buildRelationHref(lookup.relation.entityId, recordId),
-        }
-      })
-      displaysByField[fieldKey] = fieldDisplays
-    })
-  }))
-
-  return displaysByField
-}
-
-export function getRecordListRelationDisplays(
-  value: unknown,
-  displays: Record<string, ResolvedValueDisplay> | undefined,
-): Array<{ id: string; label: string; href?: string }> {
-  return collectRelationValueIds(value).map((recordId) => ({
-    id: recordId,
-    label: displays?.[recordId]?.label ?? recordId,
-    href: displays?.[recordId]?.href,
-  }))
-}

package/src/modules/entities/extension-points.ts

@@ -1,18 +0,0 @@
-import { dataTableExtensionHost, defineModuleExtensionPoints, injectionExtensionHost } from '@open-mercato/shared/modules/widgets/extension-points'
-
-export const extensionPoints = defineModuleExtensionPoints({
-  moduleId: 'entities',
-  hosts: {
-    systemEntitiesTable: dataTableExtensionHost({ tableId: 'entities.system.list', source: 'components/SystemEntitiesTable.tsx' }),
-    userEntitiesTable: dataTableExtensionHost({ tableId: 'entities.user.list', source: 'components/UserEntitiesTable.tsx' }),
-    userRecordsTable: injectionExtensionHost({
-      family: 'entity',
-      pattern: 'data-table:entities.user.records.{entityId}',
-      parameters: { entityId: { source: 'route.params.entityId' } },
-      supported: ['render-widget', 'headless-widget', 'column-widget', 'row-action', 'bulk-action', 'filter-widget'],
-      source: 'backend/entities/user/[entityId]/records/page.tsx',
-    }),
-  },
-})
-
-export default extensionPoints

package/src/modules/entities/i18n/ko.json

@@ -1,260 +0,0 @@
-{
-  "entities.customFields.addFirst": "첫 항목 추가",
-  "entities.customFields.defaultFieldset": "기본값",
-  "entities.customFields.editor.active": "활동적인",
-  "entities.customFields.editor.add": "추가하다",
-  "entities.customFields.editor.addField": "필드 추가",
-  "entities.customFields.editor.addFirstFieldset": "첫 번째 필드세트 추가",
-  "entities.customFields.editor.addOption": "옵션 추가",
-  "entities.customFields.editor.addOptionDescription": "사용자에게 표시되는 저장된 값과 선택적 라벨을 제공합니다.",
-  "entities.customFields.editor.addRule": "규칙 추가",
-  "entities.customFields.editor.assignToFieldset": "필드세트에 할당",
-  "entities.customFields.editor.cancel": "취소",
-  "entities.customFields.editor.code": "암호",
-  "entities.customFields.editor.createGroup": "그룹 만들기",
-  "entities.customFields.editor.defaultOption": "기본",
-  "entities.customFields.editor.delete": "삭제",
-  "entities.customFields.editor.deleteFieldsetText": "그러면 해당 필드가 할당되지 않음으로 이동됩니다.",
-  "entities.customFields.editor.deleteFieldsetTitle": "필드 세트 \"{code}\"를 삭제하시겠습니까?",
-  "entities.customFields.editor.deleteGroupAria": "{code} 삭제",
-  "entities.customFields.editor.description": "설명",
-  "entities.customFields.editor.dragToReorder": "드래그하여 재정렬하세요.",
-  "entities.customFields.editor.editGroup": "그룹 수정",
-  "entities.customFields.editor.editGroupAria": "{code} 편집",
-  "entities.customFields.editor.editGroupDescription": "이 필드 세트에 대해 선택한 그룹을 업데이트합니다.",
-  "entities.customFields.editor.editGroups": "그룹 수정",
-  "entities.customFields.editor.editor": "편집자",
-  "entities.customFields.editor.editorHtmlRichText": "HTML 리치 텍스트",
-  "entities.customFields.editor.editorMarkdown": "마크다운(UIW)",
-  "entities.customFields.editor.editorPlain": "일반 텍스트 영역",
-  "entities.customFields.editor.editorSimpleMarkdown": "간단한 마크다운",
-  "entities.customFields.editor.existingGroups": "기존 그룹",
-  "entities.customFields.editor.group": "그룹",
-  "entities.customFields.editor.groupCode": "그룹 코드",
-  "entities.customFields.editor.groupCodePlaceholder": "예를 들어 구매위원회",
-  "entities.customFields.editor.groupCodeRequired": "그룹 코드가 필요합니다.",
-  "entities.customFields.editor.groupHintPlaceholder": "판매자에게 표시",
-  "entities.customFields.editor.groupLabelPlaceholder": "구매위원회",
-  "entities.customFields.editor.hint": "힌트",
-  "entities.customFields.editor.icon": "상",
-  "entities.customFields.editor.iconOption.bookOpen": "도서 오픈",
-  "entities.customFields.editor.iconOption.bookmark": "서표",
-  "entities.customFields.editor.iconOption.briefcase": "서류가방",
-  "entities.customFields.editor.iconOption.building": "건물",
-  "entities.customFields.editor.iconOption.camera": "카메라",
-  "entities.customFields.editor.iconOption.car": "자동차",
-  "entities.customFields.editor.iconOption.clock": "시계",
-  "entities.customFields.editor.iconOption.cloud": "구름",
-  "entities.customFields.editor.iconOption.coins": "동전",
-  "entities.customFields.editor.iconOption.compass": "나침반",
-  "entities.customFields.editor.iconOption.creditCard": "신용카드",
-  "entities.customFields.editor.iconOption.database": "데이터 베이스",
-  "entities.customFields.editor.iconOption.flame": "불꽃",
-  "entities.customFields.editor.iconOption.gift": "선물",
-  "entities.customFields.editor.iconOption.globe": "지구",
-  "entities.customFields.editor.iconOption.grid": "그리드",
-  "entities.customFields.editor.iconOption.heart": "마음",
-  "entities.customFields.editor.iconOption.key": "열쇠",
-  "entities.customFields.editor.iconOption.layers": "레이어",
-  "entities.customFields.editor.iconOption.map": "지도",
-  "entities.customFields.editor.iconOption.package": "패키지",
-  "entities.customFields.editor.iconOption.palette": "팔레트",
-  "entities.customFields.editor.iconOption.shield": "방패",
-  "entities.customFields.editor.iconOption.shirt": "셔츠",
-  "entities.customFields.editor.iconOption.shoppingBag": "쇼핑백",
-  "entities.customFields.editor.iconOption.shoppingCart": "장바구니",
-  "entities.customFields.editor.iconOption.sparkles": "반짝임",
-  "entities.customFields.editor.iconOption.star": "별",
-  "entities.customFields.editor.iconOption.store": "가게",
-  "entities.customFields.editor.iconOption.tag": "꼬리표",
-  "entities.customFields.editor.iconOption.truck": "트럭",
-  "entities.customFields.editor.iconOption.users": "사용자",
-  "entities.customFields.editor.iconOption.zap": "기력",
-  "entities.customFields.editor.key": "열쇠",
-  "entities.customFields.editor.kind": "친절한",
-  "entities.customFields.editor.kindOption.attachment": "부착",
-  "entities.customFields.editor.kindOption.boolean": "부울",
-  "entities.customFields.editor.kindOption.currency": "통화",
-  "entities.customFields.editor.kindOption.date": "날짜",
-  "entities.customFields.editor.kindOption.datetime": "날짜/시간",
-  "entities.customFields.editor.kindOption.dictionary": "사전",
-  "entities.customFields.editor.kindOption.float": "뜨다",
-  "entities.customFields.editor.kindOption.integer": "정수",
-  "entities.customFields.editor.kindOption.multiline": "여러 줄",
-  "entities.customFields.editor.kindOption.relation": "관계",
-  "entities.customFields.editor.kindOption.select": "선택하다",
-  "entities.customFields.editor.kindOption.text": "텍스트",
-  "entities.customFields.editor.label": "상표",
-  "entities.customFields.editor.listboxSearchable": "목록 상자(검색 가능)",
-  "entities.customFields.editor.multiSelectInputStyle": "다중 선택 입력 스타일",
-  "entities.customFields.editor.multiple": "다수의",
-  "entities.customFields.editor.newFieldsetLabel": "새로운 필드셋",
-  "entities.customFields.editor.newGroup": "새 그룹",
-  "entities.customFields.editor.newGroupDescription": "이 필드 세트에 대해 재사용 가능한 그룹을 추가하십시오.",
-  "entities.customFields.editor.noFieldsets": "아직 정의된 필드 세트가 없습니다. 필드 세트를 사용하면 동일한 엔터티의 다양한 변형(예: 패션 제품과 스포츠 제품)에 대한 사용자 정의 필드를 그룹화할 수 있습니다.",
-  "entities.customFields.editor.noGroup": "그룹 없음",
-  "entities.customFields.editor.noOptionsDefined": "정의된 옵션이 없습니다.",
-  "entities.customFields.editor.noParameterPlaceholder": "-",
-  "entities.customFields.editor.noValidationRules": "정의된 유효성 검사 규칙이 없습니다.",
-  "entities.customFields.editor.optionLabelPlaceholder": "사용자에게 표시되는 라벨(선택사항)",
-  "entities.customFields.editor.options": "옵션",
-  "entities.customFields.editor.optionsSource": "옵션 소스",
-  "entities.customFields.editor.optionsUrl": "옵션 URL",
-  "entities.customFields.editor.relatedEntityId": "관련 엔터티 ID",
-  "entities.customFields.editor.removeField": "필드 삭제",
-  "entities.customFields.editor.removeOption": "옵션 제거",
-  "entities.customFields.editor.removeRule": "규칙 삭제",
-  "entities.customFields.editor.reorderedSavingSoon": "재정렬됨 - 곧 저장됨",
-  "entities.customFields.editor.restoreDeletedFields": "삭제된 필드 복원:",
-  "entities.customFields.editor.ruleErrorMessagePlaceholder": "오류 메시지",
-  "entities.customFields.editor.ruleNumberPlaceholder": "숫자",
-  "entities.customFields.editor.rulePatternPlaceholder": "패턴(예: ^[a-z]+$)",
-  "entities.customFields.editor.ruleRequiredMessage": "이 필드는 필수입니다",
-  "entities.customFields.editor.saveGroup": "그룹 저장",
-  "entities.customFields.editor.savingOrder": "주문 저장 중…",
-  "entities.customFields.editor.singleFieldsetPerEntity": "엔터티당 단일 필드 세트",
-  "entities.customFields.editor.singleFieldsetToggleHint": "(토글하려면 최소 두 개의 필드 세트를 추가하세요)",
-  "entities.customFields.editor.supportedKindsNote": "지원되는 종류: 텍스트, 여러 줄, 정수, 부동 소수점, 부울, 선택(옵션/옵션 URL 포함), 통화(고정 통화 목록), 관계(관련 엔터티 및 옵션 URL 포함).",
-  "entities.customFields.editor.translateField": "필드 번역",
-  "entities.customFields.editor.unassigned": "할당되지 않음",
-  "entities.customFields.editor.unassignedFields": "할당되지 않은 필드",
-  "entities.customFields.editor.unitsOptional": "단위(선택사항)",
-  "entities.customFields.editor.unitsPlaceholder": "kg, cm 등",
-  "entities.customFields.editor.validation.date": "날짜",
-  "entities.customFields.editor.validation.eq": "eq",
-  "entities.customFields.editor.validation.float": "뜨다",
-  "entities.customFields.editor.validation.gt": "gt",
-  "entities.customFields.editor.validation.gte": "gte",
-  "entities.customFields.editor.validation.integer": "정수",
-  "entities.customFields.editor.validation.lt": "lt",
-  "entities.customFields.editor.validation.lte": "LTE",
-  "entities.customFields.editor.validation.ne": "네",
-  "entities.customFields.editor.validation.regex": "정규식",
-  "entities.customFields.editor.validation.required": "필수의",
-  "entities.customFields.editor.validationRules": "검증 규칙",
-  "entities.customFields.editor.value": "값",
-  "entities.customFields.editor.valueRequired": "값은 필수 항목입니다.",
-  "entities.customFields.empty": "아직 지정된 커스텀 속성이 없습니다.",
-  "entities.customFields.emptyFieldset": "이 필드셋에 정의된 필드가 없습니다.",
-  "entities.customFields.errors.deleteFailed": "필드 삭제에 실패했습니다.",
-  "entities.customFields.errors.loadFailed": "필드 정의를 불러오지 못했습니다.",
-  "entities.customFields.errors.restoreFailed": "필드 복원에 실패했습니다.",
-  "entities.customFields.errors.saveFailed": "필드 정의 저장에 실패했습니다.",
-  "entities.customFields.errors.title": "문제가 발생했습니다",
-  "entities.customFields.errors.validation": "필드 정의의 유효성 검사 오류를 수정하세요.",
-  "entities.customFields.fields.defaultValue": "기본값",
-  "entities.customFields.fields.defaultValueFalse": "선택 안 됨 (false)",
-  "entities.customFields.fields.defaultValueNone": "기본값 없음",
-  "entities.customFields.fields.defaultValuePlaceholder": "기본값 없음",
-  "entities.customFields.fields.defaultValueTrue": "선택됨 (true)",
-  "entities.customFields.fields.encrypted": "암호화됨",
-  "entities.customFields.fields.filterable": "필터",
-  "entities.customFields.fields.formEditable": "양식",
-  "entities.customFields.fields.listVisible": "목록",
-  "entities.customFields.fields.visibility": "표시 여부:",
-  "entities.customFields.fieldsetSelectorLabel": "필드셋",
-  "entities.customFields.flash.restored": "필드가 복원되었습니다",
-  "entities.customFields.flash.saved": "정의가 저장되었습니다",
-  "entities.customFields.manageDialogTitle": "커스텀 필드 편집",
-  "entities.customFields.manageDialogUnavailable": "필드 정의 페이지를 사용할 수 없습니다.",
-  "entities.customFields.manageFieldset": "필드 관리",
-  "entities.customFields.openInNewTab": "전체 편집기 열기",
-  "entities.customFields.orderNotice": "순서가 변경되었습니다 — 저장하는 것을 잊지 마세요",
-  "entities.customFields.title": "커스텀 속성",
-  "entities.encryption.actions.add": "필드 추가",
-  "entities.encryption.actions.refresh": "새로고침",
-  "entities.encryption.actions.remove": "제거",
-  "entities.encryption.actions.retry": "재시도",
-  "entities.encryption.actions.save": "암호화 맵 저장",
-  "entities.encryption.actions.saving": "저장 중…",
-  "entities.encryption.active": "이 엔터티에 암호화가 활성화되어 있습니다",
-  "entities.encryption.description": "테넌트 키와 선택적 해시 열로 암호화되는 엔터티 필드를 관리합니다.",
-  "entities.encryption.empty": "아직 암호화된 필드가 없습니다. 아래에서 첫 필드를 추가하세요.",
-  "entities.encryption.entityHint": "맵은 테넌트/조직별로 적용됩니다. 엔터티의 필드 이름을 사용하세요.",
-  "entities.encryption.errors.loadEntities": "엔터티를 불러오지 못했습니다",
-  "entities.encryption.errors.loadMap": "암호화 맵을 불러오지 못했습니다",
-  "entities.encryption.errors.noFields": "암호화할 필드를 하나 이상 추가하세요",
-  "entities.encryption.errors.save": "암호화 맵 저장에 실패했습니다",
-  "entities.encryption.errors.selectEntity": "저장하기 전에 엔터티를 선택하세요",
-  "entities.encryption.fields.actions": "작업",
-  "entities.encryption.fields.field": "필드 이름",
-  "entities.encryption.fields.hash": "해시 필드 (선택 사항)",
-  "entities.encryption.fields.hashHint": "조회가 결정적이어야 할 때 사용합니다 (예: 이메일로 로그인).",
-  "entities.encryption.fields.row": "필드 {{index}}",
-  "entities.encryption.fields.selectField": "필드 선택",
-  "entities.encryption.fields.selectHash": "해시 필드 선택 (선택 사항)",
-  "entities.encryption.fields.subtitle": "테넌트 키로 암호화해야 하는 속성을 나열하세요.",
-  "entities.encryption.fields.title": "암호화된 필드",
-  "entities.encryption.flash.saved": "암호화 맵이 저장되었습니다",
-  "entities.encryption.loading": "암호화 맵을 불러오는 중…",
-  "entities.encryption.placeholder": "엔터티 선택",
-  "entities.encryption.selectEntity": "엔터티 선택",
-  "entities.encryption.source.custom": "커스텀",
-  "entities.encryption.title": "암호화",
-  "entities.nav.entityRecords": "엔터티 레코드",
-  "entities.nav.group": "데이터 디자이너",
-  "entities.nav.systemEntities": "시스템 엔터티",
-  "entities.nav.userEntities": "사용자 엔터티",
-  "entities.nav.userEntities.create": "엔터티 생성",
-  "entities.settings.description": "전역 사용자 지정 엔터티 구성을 관리합니다.",
-  "entities.settings.errors.conflict": "다른 사용자가 설정을 수정했습니다. 새로고침하세요.",
-  "entities.settings.errors.loadFailed": "설정을 로드하지 못했습니다.",
-  "entities.settings.errors.saveFailed": "설정을 저장하지 못했습니다.",
-  "entities.settings.flash.saved": "설정이 저장되었습니다.",
-  "entities.settings.newEntitiesRestrictedByDefault.description": "기본적으로 새로 생성된 사용자 지정 엔터티의 레코드에 대해 명시적인 엔터티별 권한이 필요합니다.",
-  "entities.settings.newEntitiesRestrictedByDefault.label": "기본적으로 레코드 액세스 제한",
-  "entities.settings.title": "사용자 정의 엔터티",
-  "entities.userEntities.edit.errors.deleteEntityFailed": "항목을 삭제하지 못했습니다.",
-  "entities.userEntities.edit.errors.invalidEntityDescription": "요청한 엔터티 ID가 누락되었거나 잘못되었습니다.",
-  "entities.userEntities.edit.errors.invalidEntityId": "잘못된 엔터티 ID",
-  "entities.userEntities.edit.errors.invalidEntityTitle": "잘못된 엔터티",
-  "entities.userEntities.edit.errors.loadDefinitionsFailed": "엔터티 정의를 로드하지 못했습니다.",
-  "entities.userEntities.edit.errors.loadFailed": "로드하지 못했습니다.",
-  "entities.userEntities.edit.errors.loadMetadataFailed": "항목 메타데이터를 로드하지 못했습니다.",
-  "entities.userEntities.edit.errors.reloadDefinitionsFailed": "필드 정의를 다시 로드하지 못했습니다.",
-  "entities.userEntities.edit.errors.restoreFieldFailed": "필드를 복원하지 못했습니다.",
-  "entities.userEntities.edit.errors.saveEntityFailed": "항목을 저장하지 못했습니다.",
-  "entities.userEntities.edit.errors.saveOrderFailed": "주문을 저장하지 못했습니다.",
-  "entities.userEntities.edit.errors.validationFailed": "검증 실패",
-  "entities.userEntities.edit.fieldsetTitle": "필드셋 편집: {{name}}",
-  "entities.userEntities.edit.flash.entityDeleted": "항목이 삭제되었습니다.",
-  "entities.userEntities.edit.flash.orderSaved": "주문이 저장되었습니다.",
-  "entities.userEntities.edit.flash.restoredField": "복원된 {{key}}",
-  "entities.userEntities.edit.groups.definitions": "필드 정의",
-  "entities.userEntities.edit.groups.settings": "엔터티 설정",
-  "entities.userEntities.edit.orderNotice": "재정렬됨 - 흐림 시 자동 저장됩니다.",
-  "entities.userEntities.edit.pageTitle": "정의 편집",
-  "entities.userEntities.edit.showRecords": "기록 표시",
-  "entities.userEntities.edit.title": "엔터티 편집: {{entityId}}",
-  "entities.userEntities.errors.entityIdExists": "이미 존재하는 엔터티 ID입니다",
-  "entities.userEntities.errors.entityIdRequired": "엔터티 ID는 필수입니다",
-  "entities.userEntities.errors.loadFailed": "엔터티를 불러오지 못했습니다",
-  "entities.userEntities.errors.settingsLoadFailed": "기본 제한 정책을 로드할 수 없습니다. 기본값 사용",
-  "entities.userEntities.flash.created": "엔터티가 생성되었습니다",
-  "entities.userEntities.form.accessRestricted.help": "이 엔터티의 레코드를 보거나 관리하려면 명시적인 엔터티별 권한이 필요합니다. 일반 기록 권한이 있는 사람은 누구나 허용하도록 설정하세요.",
-  "entities.userEntities.form.accessRestricted.label": "기록 접근 제한",
-  "entities.userEntities.form.defaultEditor.label": "기본 편집기 (여러 줄)",
-  "entities.userEntities.form.defaultEditor.options.default": "기본값 (Markdown)",
-  "entities.userEntities.form.defaultEditor.options.htmlRichText": "HTML 서식 있는 텍스트",
-  "entities.userEntities.form.defaultEditor.options.markdown": "Markdown (UIW)",
-  "entities.userEntities.form.defaultEditor.options.plain": "일반 텍스트 영역",
-  "entities.userEntities.form.defaultEditor.options.simpleMarkdown": "간단한 Markdown",
-  "entities.userEntities.form.description.label": "설명",
-  "entities.userEntities.form.entityId.label": "엔터티 ID",
-  "entities.userEntities.form.entityId.placeholder": "module_name:entity_id",
-  "entities.userEntities.form.label.label": "라벨",
-  "entities.userEntities.form.loading": "로드 중…",
-  "entities.userEntities.form.showInSidebar.label": "사이드바에 표시",
-  "entities.userEntities.form.submit": "생성",
-  "entities.userEntities.form.systemEntityNotice": "이는 코드에 정의된 시스템 엔터티입니다. 해당 레이블과 설명은 코드로 관리되며 여기서 편집할 수 없습니다. 아래 필드 정의만 편집 가능합니다.",
-  "entities.userEntities.form.title": "엔터티 생성",
-  "entities.userEntities.records.errors.deleteFailed": "레코드 삭제에 실패했습니다",
-  "entities.userEntities.records.errors.entityIdRequired": "엔터티 식별자는 필수입니다",
-  "entities.userEntities.records.errors.recordIdRequired": "레코드 식별자는 필수입니다",
-  "entities.userEntities.records.errors.systemEntity": "이 엔터티는 시스템에서 관리합니다. 레코드는 커스텀 엔터티에서만 사용할 수 있습니다.",
-  "entities.userEntities.records.form.createTitle": "레코드 생성",
-  "entities.userEntities.records.form.editTitle": "레코드 편집",
-  "entities.userEntities.records.form.submitCreate": "생성",
-  "entities.userEntities.records.form.submitSave": "저장",
-  "entities.userEntities.records.loading": "레코드를 불러오는 중..."
-}

package/src/modules/feature_toggles/components/hooks/staleTime.ts

@@ -1,5 +0,0 @@
-// Mirrors the server-side toggle resolution cache TTL in
-// `lib/feature-flag-check.ts`, so several components reading the same toggle
-// share one request instead of refetching a value the server would not have
-// re-resolved anyway.
-export const FEATURE_FLAG_STALE_TIME_MS = 60_000