@flamingo-stack/openframe-frontend-core 0.0.204 → 0.0.205

package/src/components/chat/utils/index.ts

@@ -33,3 +33,136 @@ export {
 
 // Tool call helpers
 export { getCommandText } from './tool-call-helpers'
+
+// Chat-side click + navigation helpers
+export { CHIP_ACTION_BUTTON_CLASS } from './chip-action-class'
+export { chatChipClass, type ChipClassOptions } from './chip-styles'
+export {
+  NEW_TAB_FEATURES,
+  isModifierClick,
+  stripSameOriginToPath,
+  resolveExternalNavigation,
+  type ExternalNavResolution,
+} from './chat-nav-resolution'
+export {
+  handleChatNavClick,
+  type ChatNavClickInput,
+} from './nav-click-handler'
+export {
+  computeIsNewTab,
+  newTabAnchorAttrs,
+  buildAnchorProps,
+} from './nav-anchor-props'
+export { isCrossOriginUrl } from './is-cross-origin-url'
+export {
+  decideNewTab,
+  type DecideNewTabInput,
+  type NavSurface,
+  type RuntimeMode,
+} from './decide-new-tab'
+
+// Chat-proxy auth (localStorage adapter + fetch wrapper)
+export {
+  getChatProxyAuth,
+  getPersistedProxyEmail,
+  setChatProxyAuth,
+  clearChatProxyAuth,
+  applyProxyAuth,
+  type ChatProxyAuth,
+} from './chat-proxy-auth-storage'
+export { chatAuthedFetch } from './chat-authed-fetch'
+
+// Pure content helpers
+export { flattenAssistantContent } from './flatten-assistant-content'
+export {
+  SCROLL_ANCHOR,
+  type ScrollAnchor,
+  SCROLL_ANCHOR_WIRE_KEY,
+  parseScrollAnchor,
+} from './scroll-anchor'
+export {
+  AUTO_CONTINUATION_DIRECTIVE_PREFIX,
+  buildAutoContinuationDirective,
+  type BuildAutoContinuationOptions,
+} from './auto-continuation-directive'
+
+// Slash-command + dispatch (lib-portable subset)
+export {
+  type WireCommandOverride,
+  parseWireCommandOverride,
+  sanitizeTitleForChat,
+  formatSingularLookupInvocation,
+  type CommandOverride,
+  extractEntityIdFilter,
+  buildDiscussAddendum,
+} from './slash-dispatch-utils'
+
+// Chat-attachment markdown formatter + strip parser
+export {
+  CHAT_ATTACHMENT_VIEW_URL_PREFIX,
+  CHAT_ATTACHMENT_VIEW_TOKEN_QUERY_PARAM,
+  ANTHROPIC_SUPPORTED_IMAGE_MIME,
+  type ChatAttachment,
+  buildChatAttachmentViewUrl,
+  escapeMarkdownInline,
+  formatChatAttachmentMarkdownForBubble,
+  CHAT_ATTACHMENT_VIEW_URL_PREFIX_REGEX_ESCAPED,
+  CHAT_ATTACHMENT_MARKDOWN_PATTERN,
+  stripChatAttachmentMarkdown,
+} from './chat-attachment-markdown'
+
+// External app deep-links (chat surfaces)
+export { clickupTaskUrl } from './external-app-urls'
+
+// Agent status → color scheme
+export { type ColorScheme, getStatusColorScheme } from './agent-status-message'
+
+// ClickUp task-type label + canonical custom_item_id map
+export { getTaskTypeLabel, CUSTOM_ITEM_ID } from './clickup-task-type-utils'
+
+// Compact-card class constants + safe-href guard
+export {
+  COMPACT_CARD_OUTER,
+  COMPACT_CARD_OUTER_STATIC,
+  COMPACT_CARD_SKELETON_OUTER,
+  COMPACT_CARD_IMAGE_SLOT,
+  COMPACT_CARD_SKELETON_IMAGE_SLOT,
+  COMPACT_CARD_ICON_SLOT,
+  COMPACT_CARD_TEXT_COL,
+  COMPACT_CARD_TITLE_ROW,
+  COMPACT_CARD_META_ROW_BOX,
+  COMPACT_CARD_TITLE,
+  COMPACT_CARD_SUBTITLE,
+  COMPACT_CARD_SUMMARY,
+  COMPACT_CARD_META_ROW,
+  COMPACT_CARD_ROW_FILLER,
+  safeHref,
+} from './compact-card-classes'
+
+// Icon + source registries (chat surfaces). The icon-registry file is
+// the SINGLE source of truth for all icon-name → React-component lookup
+// across the lib + the hub — kebab-case keys, with PascalCase aliases
+// routed through `normalizeIconKey()` for DB columns that store
+// component-style names (e.g. social_platforms.icon_name).
+export {
+  ICON_REGISTRY,
+  getIconComponent,
+  normalizeIconKey,
+  getDynamicIcon,
+  type DynamicIconSize,
+} from './icon-registry'
+export {
+  SOURCE_ICON_NAMES,
+  getSourceIconName,
+  SOURCE_LABELS_BY_TABLE,
+  getSourceLabel,
+  DEFAULT_DOCUMENT_TYPE_TO_TABLE_ID,
+  defaultTableIdForDocumentType,
+} from './source-icons'
+export {
+  type SourceRowInput,
+  type SourceRowContext,
+  type SourceRowCTA,
+  resolveSourceRowCTA,
+  resolveSourceIcon,
+} from './source-row-cta'

package/src/components/chat/utils/is-cross-origin-url.ts

@@ -0,0 +1,28 @@
+/**
+ * Pure utility — true iff `url` has an explicit host (i.e. would resolve
+ * to a different origin than where the consumer is running). Used by
+ * chat nav decisions and the extracted `decideNewTab` helper.
+ *
+ * SSR-deterministic: any URL with an explicit host (http://, https://,
+ * or protocol-relative //) is treated as cross-origin. By convention
+ * same-origin same-app navigation uses RELATIVE paths; an absolute URL
+ * with a host is external.
+ *
+ * Why deterministic: an earlier `window`-dependent implementation
+ * returned different values during SSR (false — no window) vs client
+ * hydration (true — origin differs), causing React hydration mismatches
+ * on every anchor that fell into the no-targetPlatform fallback (e.g.
+ * footer "Support" links to flamingo.run/support). Same-platform
+ * absolute URLs (rare — they only happen when a composer like
+ * `buildContentURL` returns an absolute URL for a non-current platform)
+ * flow through `decideNewTab`'s PLATFORM branch first (which uses
+ * `targetPlatform !== currentSource`) and never reach this fallback.
+ */
+export function isCrossOriginUrl(url: string | null | undefined): boolean {
+  if (!url) return false
+  // Relative URL — by definition same origin.
+  if (url.startsWith('/') && !url.startsWith('//')) return false
+  // Anything else — absolute URL (http(s)://) or protocol-relative (//)
+  // — is treated as cross-origin.
+  return true
+}

package/src/components/chat/utils/nav-anchor-props.ts

@@ -0,0 +1,78 @@
+/**
+ * Pure helpers for the new-tab decision + anchor attribute pair used
+ * by chat-rendered links.
+ *
+ * After the navigation unification (ChatCardLoader pre-resolves
+ * `chatRef.url` via `resolveSourceRowCTA` + `resolveHrefForRuntime`,
+ * and `ChatCardNavWrap` handles every primary click via `onClickCapture`
+ * → `handleChatNavClick`), the per-card wrapper only needs
+ * `{href, target, rel}` on its inner `<a>` so modifier-click /
+ * hover-preview / copy-link work natively.
+ *
+ * `computeIsNewTab` is the SINGLE source of the new-tab rule across
+ * inline cards, source chips, and `NavLinkAnchorViaRuntime`. Do NOT
+ * inline the `runtime.navigation.mode === 'embed'` short-circuit + the
+ * `decideNewTab` fallback chain anywhere else.
+ *
+ * Rules:
+ *   - `embed` mode → ALWAYS new-tab. The chat lives on the embedder
+ *     origin; content lives on the hub. Same-tab nav would leave the
+ *     embedder entirely.
+ *   - `host` mode → defer to the runtime's `decideNewTab` callback
+ *     (cross-platform → new-tab) or the lib's default.
+ */
+
+import type { ChatRuntime } from '../../../contexts/chat-runtime-context'
+import { decideNewTab as libDecideNewTab } from './decide-new-tab'
+
+export function computeIsNewTab(
+  runtime: ChatRuntime,
+  href: string | null | undefined,
+  targetPlatform: string | null,
+): boolean {
+  if (!href) return false
+  if (runtime.navigation.mode === 'embed') return true
+  return (
+    runtime.navigation.decideNewTab?.({ href, targetPlatform }) ??
+    libDecideNewTab({
+      href,
+      targetPlatform,
+      currentSource: runtime.source ?? '',
+    })
+  )
+}
+
+/**
+ * Returns the `target` + `rel` attribute pair for an inner `<a>` based
+ * on the new-tab decision. Spread directly into JSX:
+ *   <a href={href} {...newTabAnchorAttrs(isNewTab)} />
+ *
+ * Single helper so chat anchors stay consistent — new-tab links always
+ * pair `_blank` with `noopener noreferrer` (defense against window.opener
+ * tab-nabbing) and same-tab links don't render either attribute.
+ */
+export function newTabAnchorAttrs(isNewTab: boolean): {
+  target?: '_blank'
+  rel?: 'noopener noreferrer'
+} {
+  return isNewTab
+    ? { target: '_blank' as const, rel: 'noopener noreferrer' as const }
+    : {}
+}
+
+/**
+ * Combine `href` + new-tab attrs into a card's `anchorProps` slot.
+ * Returns `undefined` (not a falsy object) when there's no URL, so card
+ * components can branch on `anchorProps != null` to render either a
+ * clickable `<a>` or a static `<span>`.
+ *
+ * Replaces the repeated inline
+ * `chatRef.url ? { href: chatRef.url, ...newTabAnchorAttrs(isNewTab) } : undefined`
+ * pattern across the 7 dispatcher wrappers.
+ */
+export function buildAnchorProps(
+  href: string | null | undefined,
+  isNewTab: boolean,
+): { href: string; target?: '_blank'; rel?: 'noopener noreferrer' } | undefined {
+  return href ? { href, ...newTabAnchorAttrs(isNewTab) } : undefined
+}

package/src/components/chat/utils/nav-click-handler.ts

@@ -0,0 +1,81 @@
+/**
+ * Pure click-handler helper for chat-rendered nav links.
+ *
+ * Single click router shared by:
+ *   - The chip block inside EmbeddableChat
+ *   - `<ChatCardNavWrap>` inside the entity-card dispatcher
+ *   - `<NavLinkAnchorViaRuntime>` (markdown-body anchor wrapper)
+ *
+ * Returns `true` when the handler took action (called preventDefault); the
+ * caller can treat that as "I handled it" and skip any further routing.
+ * Returns `false` for modifier-clicks / non-primary buttons — those pass
+ * through to the browser's default behavior (open in new tab, etc.).
+ *
+ * The new-tab decision (`computeIsNewTab` — embed-mode short-circuit +
+ * `runtime.navigation.decideNewTab` + lib fallback) is the single source
+ * of truth and is consumed here directly. No caller needs to duplicate
+ * the embed-vs-host logic.
+ *
+ * Routing rules:
+ *   - Empty href → preventDefault + return true (no-op nav)
+ *   - Non-primary mouse button OR any modifier key → return false (let
+ *     the browser handle it; `<a>` semantics take over)
+ *   - new-tab (`computeIsNewTab` true) → `runtime.navigation.openExternal`
+ *     or `window.open(href, '_blank')`. Covers embed mode and
+ *     cross-platform host mode uniformly.
+ *   - same-tab → `runtime.navigation.navigate?.(…)` → fallback
+ *     `window.location.assign(stripSameOriginToPath(href))`
+ */
+
+import { computeIsNewTab } from './nav-anchor-props'
+import { NEW_TAB_FEATURES, stripSameOriginToPath } from './chat-nav-resolution'
+import type { ChatRuntime } from '../../../contexts/chat-runtime-context'
+
+export interface ChatNavClickInput {
+  href: string
+  path?: string | null
+  targetPlatform?: string | null
+}
+
+/**
+ * Minimal mouse-event surface the click handler needs. Accepting a
+ * structural type rather than `React.MouseEvent<HTMLAnchorElement>` keeps
+ * the helper callable from non-anchor surfaces (chip buttons, tile
+ * containers) without forcing a cast.
+ */
+interface NavClickEvent {
+  preventDefault(): void
+  button?: number
+  metaKey?: boolean
+  ctrlKey?: boolean
+  shiftKey?: boolean
+  altKey?: boolean
+}
+
+export function handleChatNavClick(
+  e: NavClickEvent,
+  runtime: ChatRuntime,
+  { href, path, targetPlatform }: ChatNavClickInput,
+): boolean {
+  if (!href) {
+    e.preventDefault()
+    return true
+  }
+  if (e.button !== undefined && e.button !== 0) return false
+  if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return false
+
+  e.preventDefault()
+  const isNewTab = computeIsNewTab(runtime, href, targetPlatform ?? null)
+  if (isNewTab) {
+    if (runtime.navigation.openExternal) {
+      runtime.navigation.openExternal(href)
+    } else {
+      window.open(href, '_blank', NEW_TAB_FEATURES)
+    }
+    return true
+  }
+  const handled =
+    runtime.navigation.navigate?.({ href, path, targetPlatform }) ?? false
+  if (!handled) window.location.assign(stripSameOriginToPath(href))
+  return true
+}

package/src/components/chat/utils/scroll-anchor.ts

@@ -0,0 +1,35 @@
+/**
+ * Wire glue + canonical const for the per-message `scrollAnchor`
+ * render hint.
+ *
+ * The actual `SCROLL_ANCHOR` const + `ScrollAnchor` type lives in
+ * `../types/message.types.ts` (it's part of the `Message` shape). This
+ * module re-exports them alongside the wire-key + a `parseScrollAnchor`
+ * narrower so server-side code that emits the metadata leading frame and
+ * client-side code that consumes it agree on the literal value AND the
+ * key on the wire frame.
+ *
+ * Consumed by:
+ *   - SERVER: emits the field into the metadata leading frame
+ *     (`...(scrollAnchor ? { [SCROLL_ANCHOR_WIRE_KEY]: x } : {})`).
+ *   - CLIENT: parses each leading frame and feeds the value through
+ *     `parseScrollAnchor` before storing it for the chat-message-list
+ *     to consume. Malformed wire values return `null` and are filtered
+ *     by metadata-merge logic — they never clobber a prior value.
+ */
+
+import { SCROLL_ANCHOR, type ScrollAnchor } from '../types/message.types'
+
+export { SCROLL_ANCHOR, type ScrollAnchor }
+
+/** Wire-frame key for the `scrollAnchor` field on the metadata leading
+ *  frame. Used as a computed property name on both the emit side
+ *  (server) and the parse side (client) so a rename is one-file. */
+export const SCROLL_ANCHOR_WIRE_KEY = "scrollAnchor" as const
+
+/** Narrow + validate a wire-supplied value. Returns the literal when
+ *  it matches one of the registry's known values; returns `null`
+ *  otherwise (which the metadata-merge null-skip filter then drops). */
+export function parseScrollAnchor(raw: unknown): ScrollAnchor | null {
+  return raw === SCROLL_ANCHOR.TOP || raw === SCROLL_ANCHOR.BOTTOM ? raw : null
+}

package/src/components/chat/utils/slash-dispatch-utils.ts

@@ -0,0 +1,183 @@
+/**
+ * Lib-side portable subset of the hub's `lib/utils/slash-dispatch-utils.ts`.
+ *
+ * The full hub file owns the SERVER-SIDE parser/dispatcher (depends on
+ * `slash-commands-config`, `slash-commands-static`, `doc-source-config-utils`,
+ * `chat-admin-types`, `rag-table-config`) which stays hub-side.
+ *
+ * What MIGRATES here is the wire contract + the small text helpers consumed
+ * by chat surfaces in the lib + the hub UI:
+ *   - `WireCommandOverride`        — wire-shape (chat request body)
+ *   - `parseWireCommandOverride`   — wire validator
+ *   - `CommandOverride`            — server-built dispatch result type
+ *     (presentation typed as `string` here; the hub narrows via its own
+ *     `SlashCommandPresentation` union)
+ *   - `extractEntityIdFilter`      — `CommandOverride` → narrowed filter
+ *   - `sanitizeTitleForChat`       — collapse control chars in titles
+ *   - `formatSingularLookupInvocation` — `/cmd "value"` builder
+ *   - `buildDiscussAddendum`       — server-side Discuss addendum prose
+ *
+ * Validation constants (regex + length caps) are duplicated here verbatim
+ * to keep the lib's wire validator self-contained.
+ */
+
+const WIRE_TABLE_ID_REGEX = /^[a-z][a-z0-9-]*$/
+const WIRE_ID_REGEX = /^[A-Za-z0-9._:/-]+$/
+const WIRE_TABLE_ID_MAX = 60
+const WIRE_ID_MAX = 200
+const WIRE_QUERY_MAX = 2000
+
+/** Wire-supplied `CommandOverride` — the subset of fields a client (chat
+ *  shell) is allowed to send on the request body. Excludes
+ *  `systemPromptAddendum` by construction: addendum injection is a
+ *  Rule-5b bypass vector, so we never accept it from the wire. */
+export interface WireCommandOverride {
+  entityIdFilter?: { tableId: string; id: string }
+  retrievalQueryOverride?: string
+}
+
+/**
+ * Parse + validate a wire-supplied `commandOverride` from the chat
+ * request body. Returns the validated subset OR `null` if the input is
+ * missing / malformed in every field.
+ */
+export function parseWireCommandOverride(raw: unknown): WireCommandOverride | null {
+  if (!raw || typeof raw !== 'object') return null
+  const out: WireCommandOverride = {}
+  const r = raw as Record<string, unknown>
+
+  if (r.entityIdFilter && typeof r.entityIdFilter === 'object') {
+    const f = r.entityIdFilter as Record<string, unknown>
+    if (
+      typeof f.tableId === 'string'
+      && f.tableId.length > 0
+      && f.tableId.length <= WIRE_TABLE_ID_MAX
+      && WIRE_TABLE_ID_REGEX.test(f.tableId)
+      && typeof f.id === 'string'
+      && f.id.length > 0
+      && f.id.length <= WIRE_ID_MAX
+      && WIRE_ID_REGEX.test(f.id)
+    ) {
+      out.entityIdFilter = { tableId: f.tableId, id: f.id }
+    }
+  }
+  if (
+    typeof r.retrievalQueryOverride === 'string'
+    && r.retrievalQueryOverride.length > 0
+    && r.retrievalQueryOverride.length <= WIRE_QUERY_MAX
+  ) {
+    out.retrievalQueryOverride = r.retrievalQueryOverride
+  }
+  if (out.entityIdFilter === undefined && out.retrievalQueryOverride === undefined) {
+    return null
+  }
+  return out
+}
+
+/**
+ * Sanitize a free-text title for use inside a chat-visible string:
+ * collapse control chars (\r \n \t) to single spaces and trim. Defends
+ * against a row title containing embedded newlines (which would split
+ * the rendered prompt across visible lines + survive into ILIKE in a
+ * confusing way) and tab/CR artifacts from sloppy imports.
+ */
+export function sanitizeTitleForChat(value: string | null | undefined): string {
+  return (value ?? '').replace(/[\r\n\t]+/g, ' ').trim()
+}
+
+/**
+ * Compose a singular-lookup slash invocation as the user-visible chat
+ * message: `/<cmd> "<value>"` (or `/<cmd>` when value is empty).
+ *
+ * SINGLE SOURCE OF TRUTH for the quoting convention `parseSlashCommand`
+ * consumes: outer `"`-pair triggers `singularLookup`; unquoted args run
+ * FTS; empty args browse. Internal `"` chars are backslash-escaped so
+ * the visible string is paste-able / re-runnable.
+ */
+export function formatSingularLookupInvocation(cmdId: string, value?: string | null): string {
+  // Escape `\` BEFORE `"` — otherwise a value ending in `\` survives the
+  // `"`-escape pass and, when wrapped in `"..."`, the trailing `\"`
+  // becomes a literal `"` to a parser that processes backslash escapes,
+  // breaking the close quote. CodeQL's `js/incomplete-sanitization` fires
+  // on the previous one-pass `\"` escape for exactly this reason.
+  const safe = sanitizeTitleForChat(value)
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+  return safe ? `/${cmdId} "${safe}"` : `/${cmdId}`
+}
+
+/** Command-override structure passed to `buildChatContext.opts.commandOverride`. */
+export interface CommandOverride {
+  retrievalScope?: string[]
+  systemPromptAddendum?: string
+  retrievalQueryOverride?: string | null
+  /** Singular-item lookup. When set, retrieval bypasses FTS and queries the
+   *  named table directly via ILIKE on the matchFields. */
+  entityLookup?: {
+    tableId: string
+    value: string
+    matchFields: string[]
+  }
+  /** Singular row by primary key. Used by the inline object-card
+   *  "Discuss" action — the client knows the exact row id from a prior
+   *  chip. Higher precedence than `entityLookup` (route enforces) and
+   *  `retrievalQueryOverride`. The retrieval layer still runs the table's
+   *  `searchFilter` so privacy invariants hold. */
+  entityIdFilter?: {
+    tableId: string
+    id: string
+  }
+  /** "Browse" bypass for bare slash list commands. The search layer
+   *  treats this as "skip FTS — return rows from these tableIds ordered
+   *  by the configured `primaryDateColumn` DESC". */
+  browseScope?: string[]
+  /** Presentation hint propagated from the slash command. Hub narrows to
+   *  its `SlashCommandPresentation` union; lib leaves as `string` for
+   *  decoupling. */
+  presentation?: string
+}
+
+/**
+ * Resolve the wire `entityIdFilter` from a `CommandOverride`, optionally
+ * narrowed to a specific `tableId`. Returns the validated `{ tableId, id }`
+ * pair only when both fields are present, non-empty, and (when an expected
+ * tableId is passed) match. Returns `null` otherwise.
+ */
+export function extractEntityIdFilter(
+  override: CommandOverride | null | undefined,
+  expectedTableId?: string,
+): { tableId: string; id: string } | null {
+  const f = override?.entityIdFilter
+  if (!f) return null
+  const tableId = typeof f.tableId === 'string' ? f.tableId : ''
+  const id = typeof f.id === 'string' ? f.id : ''
+  if (!tableId || !id) return null
+  if (expectedTableId && tableId !== expectedTableId) return null
+  return { tableId, id }
+}
+
+/**
+ * Server-only synthesizer for the Discuss-action system-prompt addendum.
+ * Called by the chat route AFTER `parseWireCommandOverride` accepts an
+ * `entityIdFilter` — the addendum text is composed from server-trusted
+ * values (the row's tableId + id) so a malicious client can't inject
+ * arbitrary prompt content.
+ */
+export function buildDiscussAddendum(args: { tableId: string; id: string }): string {
+  const idTag = args.id.length > 24 ? args.id.slice(0, 24) + '…' : args.id
+  return (
+    `Ask drill-in for row id="${args.id}" in table "${args.tableId}". Focus the ` +
+    `answer on this single record. If retrieval returns 0 rows (privacy ` +
+    `filter), say so plainly per Rule 5b.\n\n` +
+    `OPEN with the inline card on the FIRST line, immediately followed by ` +
+    `the chip and a mono-font id tag — no prose before the card:\n` +
+    `    [card://<type>:${args.id}] [N] \`${args.tableId} · ${idTag}\`\n` +
+    `Use the EXACT <type> from the row's <document type="..." id="${args.id}"> tag.\n\n` +
+    `SURFACE EVERY FIELD PRESENT in the retrieved record — the user already ` +
+    `knows the title from the card; the value of Ask is the BODY (description, ` +
+    `status, vote counts, dates, linked URLs, …). Walk each non-empty field. ` +
+    `Don't invent fields, don't hallucinate values, silently omit absent fields.\n\n` +
+    `FORMAT: card+chip+id-tag opener, then ONE framing sentence, then a compact ` +
+    `bulleted "**Field** — value" list. Don't restate fields already in the list.`
+  )
+}

package/src/components/chat/utils/source-icons.ts

@@ -0,0 +1,14 @@
+/**
+ * Client-side re-export shim. Source-icons data + helpers live in
+ * `src/utils/source-icons.ts` (server-safe, no `'use client'` banner)
+ * so server-side hub code can call them. Chat-side consumers continue
+ * importing from this path via the chat-utils barrel.
+ */
+export {
+  SOURCE_ICON_NAMES,
+  getSourceIconName,
+  SOURCE_LABELS_BY_TABLE,
+  getSourceLabel,
+  DEFAULT_DOCUMENT_TYPE_TO_TABLE_ID,
+  defaultTableIdForDocumentType,
+} from '../../../utils/source-icons'