Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat(dashboards): add the canvas picker and settings modal for canvas app tiles (#114233)

Daniel Viscaf068d7211785
diff --git a/frontend/snapshots.yml b/frontend/snapshots.yml
index cc118ed2c9f7..8409f6b07c5e 100644
--- a/frontend/snapshots.yml
+++ b/frontend/snapshots.yml
@@ -6870,6 +6870,14 @@ snapshots:
hash: v1.k794b7964.9572c4979a6934a94886531af0d64845148e3417b98fe8010c677420bbd1f3b7.zdaJR_5DwY5IX5qeFfu9O2I6VajkSqqv9XU46z8HcMQ
products-dashboards-dashboard-widgets-widget-types-activity-recent-events--tile-filters-read-only--light:
hash: v1.k794b7964.355b2fe7000461fbb2fb166e627e8f9b4f39631649ff62fd9966c69fa990f94e.GcjA3-hBC1df2mGFD0d6crjPeEbeOnwEZLOICsPTp6Y
+ products-dashboards-dashboard-widgets-widget-types-canvas-canvas-app-widget-settings--default--dark:
+ hash: v1.k794b7964.ca92a759abc1822693d6065dba266039e51715a55500585faa2c53982304b214.WNCPKOtHIS1BZuO06dIjRhBREKOJXce328yi8xfAnDc
+ products-dashboards-dashboard-widgets-widget-types-canvas-canvas-app-widget-settings--default--light:
+ hash: v1.k794b7964.ec9689b0dd77a08cdf3db21e1c4b31a971ae9bc613e96020f8c38c6f580a8d03.26ASqIdeg3tr4iUF6GSqlvkpMD5HaOUWt_dXoITysB4
+ products-dashboards-dashboard-widgets-widget-types-canvas-canvas-app-widget-settings--no-canvas-selected--dark:
+ hash: v1.k794b7964.c000be8f30049d3a0784e85c23e265e4a1a631bf2f9350d46c5d93a8f5e2b1da.MOfMIlYUUHMlLKBSk75b4hbtV3QXMCA0UY02s2FXaBU
+ products-dashboards-dashboard-widgets-widget-types-canvas-canvas-app-widget-settings--no-canvas-selected--light:
+ hash: v1.k794b7964.ce08cd0a1dce9ea81b3b8e3324a10393b6a42afb4740a65b0b2ef7bdd0340646.gbr4nk1WAbomPR7y3lGRqD6rSP6iW7jXOxmXwqwi4-A
products-dashboards-dashboard-widgets-widget-types-error-tracking-top-issues--default--dark:
hash: v1.k794b7964.0c5e48132f055382561335fea973ddf546cf7216ce997c00e4c5d871838bbb1f.ALpVMICEU6x_cD5zCzaVXJBuqGqjWXHVTivfn-jrmik
products-dashboards-dashboard-widgets-widget-types-error-tracking-top-issues--default--light:
diff --git a/products/dashboards/frontend/widget_types/catalog.ts b/products/dashboards/frontend/widget_types/catalog.ts
index 7433e8afe098..cd542d2174d3 100644
--- a/products/dashboards/frontend/widget_types/catalog.ts
+++ b/products/dashboards/frontend/widget_types/catalog.ts
@@ -1,6 +1,15 @@
import type { ComponentType } from 'react'
-import { IconFlask, IconList, IconLive, IconMessage, IconNotebook, IconRewindPlay, IconWarning } from '@posthog/icons'
+import {
+ IconApps,
+ IconFlask,
+ IconList,
+ IconLive,
+ IconMessage,
+ IconNotebook,
+ IconRewindPlay,
+ IconWarning,
+} from '@posthog/icons'
import { urls } from 'scenes/urls'
@@ -81,6 +90,7 @@ export const DASHBOARD_WIDGET_GROUP_LABELS = {
surveys: 'Surveys',
logs: 'Logs',
conversations: 'Support',
+ canvas: 'Canvas',
} as const satisfies Record<string, string>
export function getDashboardWidgetGroupLabel(groupId: string): string {
@@ -97,6 +107,7 @@ export const DASHBOARD_WIDGET_GROUP_ICONS = {
surveys: IconMessage,
logs: IconList,
conversations: IconMessage,
+ canvas: IconApps,
} as const satisfies Record<keyof typeof DASHBOARD_WIDGET_GROUP_LABELS, ComponentType<{ className?: string }>>
export function getDashboardWidgetGroupIcon(groupId: string): ComponentType<{ className?: string }> | undefined {
diff --git a/products/dashboards/frontend/widgets/canvas/CanvasOptionLabel.tsx b/products/dashboards/frontend/widgets/canvas/CanvasOptionLabel.tsx
new file mode 100644
index 000000000000..1ba8ebf59f22
--- /dev/null
+++ b/products/dashboards/frontend/widgets/canvas/CanvasOptionLabel.tsx
@@ -0,0 +1,23 @@
+import { ProfilePicture } from 'lib/lemon-ui/ProfilePicture'
+import { fullName } from 'lib/utils/strings'
+
+import type { CanvasApi } from 'products/canvas/frontend/generated/api.schemas'
+
+export function CanvasOptionLabel({ canvas }: { canvas: CanvasApi }): JSX.Element {
+ const creator = canvas.created_by
+ const creatorName = creator ? fullName(creator) || creator.email : null
+ return (
+ <span className="flex w-full items-center justify-between gap-2">
+ <span className="min-w-0 flex-1 truncate">{canvas.name}</span>
+ {creator ? (
+ <span className="inline-flex shrink-0 items-center gap-1 text-xs text-muted">
+ <ProfilePicture
+ user={{ first_name: creator.first_name, last_name: creator.last_name, email: creator.email }}
+ size="sm"
+ />
+ <span className="max-w-32 truncate">{creatorName}</span>
+ </span>
+ ) : null}
+ </span>
+ )
+}
diff --git a/products/dashboards/frontend/widgets/canvas/CanvasPickerSelect.tsx b/products/dashboards/frontend/widgets/canvas/CanvasPickerSelect.tsx
new file mode 100644
index 000000000000..4575aaed0f62
--- /dev/null
+++ b/products/dashboards/frontend/widgets/canvas/CanvasPickerSelect.tsx
@@ -0,0 +1,116 @@
+import { useActions, useValues } from 'kea'
+import { useEffect, useMemo } from 'react'
+
+import { LemonButton } from 'lib/lemon-ui/LemonButton'
+import { LemonInputSelect, type LemonInputSelectOption } from 'lib/lemon-ui/LemonInputSelect'
+
+import type { CanvasApi } from 'products/canvas/frontend/generated/api.schemas'
+
+import { CanvasOptionLabel } from './CanvasOptionLabel'
+import { canvasPickerLogic } from './canvasPickerLogic'
+
+export type CanvasPickerSelectProps = {
+ /** Isolates picker state per mount (modal vs. each tile). */
+ pickerKey: string
+ value: string | null
+ onChange: (canvasId: string | null) => void
+ disabled?: boolean
+ size?: 'small' | 'medium'
+ fullWidth?: boolean
+ dataAttr?: string
+}
+
+export function CanvasPickerSelect({
+ pickerKey,
+ value,
+ onChange,
+ disabled,
+ size = 'small',
+ fullWidth = false,
+ dataAttr,
+}: CanvasPickerSelectProps): JSX.Element {
+ const logic = canvasPickerLogic({ pickerKey })
+ const { canvasOptions, canvasOptionsLoading, canvasOptionsFailed, selectedCanvas, selectedCanvasFailed, search } =
+ useValues(logic)
+ const { ensureOptionsLoaded, retryLoadOptions, setSearch, ensureSelectedLoaded } = useActions(logic)
+
+ // Resolve the selected label even when it falls outside the loaded/searched page.
+ useEffect(() => {
+ if (value) {
+ ensureSelectedLoaded(value)
+ }
+ }, [value, ensureSelectedLoaded])
+
+ const options = useMemo((): LemonInputSelectOption[] => {
+ const byId = new Map<string, CanvasApi>()
+ if (selectedCanvas) {
+ byId.set(selectedCanvas.id, selectedCanvas)
+ }
+ for (const canvas of canvasOptions) {
+ byId.set(canvas.id, canvas)
+ }
+ return Array.from(byId.values(), (canvas) => ({
+ key: canvas.id,
+ label: canvas.name,
+ labelComponent: <CanvasOptionLabel canvas={canvas} />,
+ }))
+ }, [canvasOptions, selectedCanvas])
+
+ return (
+ <LemonInputSelect
+ mode="single"
+ size={size}
+ fullWidth={fullWidth}
+ placeholder="Select a canvas"
+ loading={canvasOptionsLoading}
+ disabled={disabled}
+ disableFiltering
+ value={value ? [value] : []}
+ options={options}
+ // A failed request must stay visible even when a resolved selection or earlier results fill the list,
+ // so the errors and retries live in the always-rendered title rather than the empty state.
+ title={
+ canvasOptionsFailed || (value && selectedCanvasFailed) ? (
+ <span className="flex flex-col gap-1 font-normal">
+ {value && selectedCanvasFailed ? (
+ <span className="flex items-center justify-between gap-2">
+ <span className="text-danger">Couldn't load the selected canvas.</span>
+ <LemonButton size="xsmall" type="secondary" onClick={() => ensureSelectedLoaded(value)}>
+ Try again
+ </LemonButton>
+ </span>
+ ) : null}
+ {canvasOptionsFailed ? (
+ <span className="flex items-center justify-between gap-2">
+ <span className="text-danger">Couldn't load canvases.</span>
+ <LemonButton size="xsmall" type="secondary" onClick={() => retryLoadOptions()}>
+ Try again
+ </LemonButton>
+ </span>
+ ) : null}
+ </span>
+ ) : undefined
+ }
+ emptyStateComponent={
+ canvasOptionsFailed ? (
+ // The title already explains the failure; an empty message here would claim there are no canvases.
+ <></>
+ ) : (
+ <p className="text-secondary italic p-1">
+ {search ? `No canvases matching "${search}"` : 'No canvases yet'}
+ </p>
+ )
+ }
+ onFocus={() => {
+ ensureOptionsLoaded()
+ // Refocusing also retries a selected canvas that failed to resolve.
+ if (value && selectedCanvasFailed) {
+ ensureSelectedLoaded(value)
+ }
+ }}
+ onInputChange={(text) => setSearch(text)}
+ onChange={(values) => onChange(values.length > 0 ? values[0] : null)}
+ data-attr={dataAttr}
+ />
+ )
+}
diff --git a/products/dashboards/frontend/widgets/canvas/EditCanvasAppWidgetModal.stories.tsx b/products/dashboards/frontend/widgets/canvas/EditCanvasAppWidgetModal.stories.tsx
new file mode 100644
index 000000000000..09be1bd90efb
--- /dev/null
+++ b/products/dashboards/frontend/widgets/canvas/EditCanvasAppWidgetModal.stories.tsx
@@ -0,0 +1,92 @@
+import type { Meta, StoryObj } from '@storybook/react'
+
+import { mswDecorator } from '~/mocks/browser'
+
+import { widgetStorybookParameters } from '../../components/WidgetCard/widgetCardStoryFixtures'
+import { canvasAppWidgetConfigSchema } from '../../generated/widget-configs.zod'
+import type { DashboardWidgetEditModalProps } from '../registry'
+import { EditCanvasAppWidgetModal } from './EditCanvasAppWidgetModal'
+
+const DEFAULT_CONFIG = canvasAppWidgetConfigSchema.parse({}) as Record<string, unknown>
+// Must pass z.uuid(), or the config parser drops it and the story renders with no canvas selected.
+const CANVAS_ID = '0192f1c4-7b2e-7d3a-9f00-123456789abc'
+
+const sampleCanvas = {
+ id: CANVAS_ID,
+ name: 'Support console',
+ kind: 'freeform',
+ description: '',
+ channel: 'space-1',
+ template_id: 'freeform',
+ generation_task_id: null,
+ pinned: false,
+ pinned_at: null,
+ current_version_id: 'version-1',
+ published_build_id: 'build-1',
+ component_meta: null,
+ created_by: { id: 1, uuid: 'u', distinct_id: 'd', first_name: 'Ada', last_name: '', email: '[email protected]' },
+ created_at: '2026-05-20T10:00:00Z',
+ updated_at: '2026-05-20T10:00:00Z',
+ url: `/canvases/${CANVAS_ID}`,
+}
+
+// The settings modal embeds the canvas picker (canvasPickerLogic) — mock the list/retrieve endpoints so the
+// options and the selected canvas resolve.
+const canvasesApiDecorator = mswDecorator({
+ get: {
+ '/api/projects/:team_id/canvases/': () => [200, { results: [sampleCanvas], count: 1 }],
+ '/api/projects/:team_id/canvases/:id/': () => [200, sampleCanvas],
+ },
+})
+
+type EditCanvasAppWidgetModalStoryProps = Partial<DashboardWidgetEditModalProps>
+
+function EditCanvasAppWidgetModalStory({
+ isOpen = true,
+ onClose = () => undefined,
+ onSave = () => Promise.resolve(),
+ config = DEFAULT_CONFIG,
+ name = 'Canvas app',
+ defaultTitle = 'Canvas app',
+ description = "A published canvas app, rendered with each viewer's own permissions.",
+ ...props
+}: EditCanvasAppWidgetModalStoryProps): JSX.Element {
+ return (
+ <EditCanvasAppWidgetModal
+ isOpen={isOpen}
+ onClose={onClose}
+ config={config}
+ onSave={onSave}
+ name={name}
+ defaultTitle={defaultTitle}
+ description={description}
+ {...props}
+ />
+ )
+}
+
+// Storybook CSF requires a string literal `title` derived from catalog groupLabel/label.
+const meta: Meta<typeof EditCanvasAppWidgetModalStory> = {
+ title: 'Products/Dashboards/Dashboard Widgets/Widget types/Canvas/Canvas app/Widget settings',
+ component: EditCanvasAppWidgetModalStory,
+ parameters: {
+ layout: 'fullscreen',
+ ...widgetStorybookParameters,
+ },
+ decorators: [canvasesApiDecorator],
+ args: {
+ config: { ...DEFAULT_CONFIG, canvasId: CANVAS_ID },
+ },
+}
+
+export default meta
+
+type Story = StoryObj<typeof EditCanvasAppWidgetModalStory>
+
+export const Default: Story = {}
+
+export const NoCanvasSelected: Story = {
+ args: {
+ config: DEFAULT_CONFIG,
+ },
+}
diff --git a/products/dashboards/frontend/widgets/canvas/EditCanvasAppWidgetModal.tsx b/products/dashboards/frontend/widgets/canvas/EditCanvasAppWidgetModal.tsx
new file mode 100644
index 000000000000..aa8842920746
--- /dev/null
+++ b/products/dashboards/frontend/widgets/canvas/EditCanvasAppWidgetModal.tsx
@@ -0,0 +1,109 @@
+import { BindLogic, useActions, useValues } from 'kea'
+
+import { LemonButton } from 'lib/lemon-ui/LemonButton'
+import { LemonDivider } from 'lib/lemon-ui/LemonDivider'
+import { LemonField } from 'lib/lemon-ui/LemonField/LemonField'
+import { LemonModal } from 'lib/lemon-ui/LemonModal'
+
+import { getDashboardWidgetGroupLabel } from '../../widget_types/catalog'
+import { EditWidgetModalTileDetailsSection } from '../EditWidgetModalTileDetailsSection'
+import type { DashboardWidgetEditModalProps } from '../registry'
+import { CanvasPickerSelect } from './CanvasPickerSelect'
+import { editCanvasAppWidgetModalLogic } from './editCanvasAppWidgetModalLogic'
+
+function EditCanvasAppWidgetModalContents(): JSX.Element {
+ const {
+ canvasId,
+ tileName,
+ tileDescription,
+ activeFieldErrors,
+ saving,
+ saveDisabledReason,
+ onClose,
+ defaultTitle,
+ } = useValues(editCanvasAppWidgetModalLogic)
+ const { setCanvasId, setTileName, setTileDescription, clearFieldError, submit } =
+ useActions(editCanvasAppWidgetModalLogic)
+
+ return (
+ <LemonModal
+ isOpen
+ onClose={onClose}
+ title="Widget settings"
+ description="Pick the canvas to show on this tile. Each viewer sees it with their own permissions."
+ width={680}
+ footer={
+ <>
+ <div className="flex-1" />
+ <LemonButton type="secondary" onClick={onClose} disabled={saving}>
+ Cancel
+ </LemonButton>
+ <LemonButton
+ type="primary"
+ loading={saving}
+ disabledReason={saveDisabledReason}
+ onClick={() => submit()}
+ >
+ Save
+ </LemonButton>
+ </>
+ }
+ >
+ <div className="flex flex-col gap-4">
+ <EditWidgetModalTileDetailsSection
+ tileName={tileName}
+ tileDescription={tileDescription}
+ defaultTitle={defaultTitle}
+ saving={saving}
+ setTileName={setTileName}
+ setTileDescription={setTileDescription}
+ />
+ <LemonDivider className="my-0" />
+ <section className="flex flex-col gap-3">
+ <h5 className="text-sm font-semibold m-0">{getDashboardWidgetGroupLabel('canvas')}</h5>
+ <LemonField.Pure
+ label="Canvas"
+ help="Only canvases you can see are listed. Viewers who cannot see the canvas get a placeholder."
+ error={activeFieldErrors.canvasId}
+ >
+ <CanvasPickerSelect
+ pickerKey="edit-canvas-app-widget-modal"
+ value={canvasId}
+ disabled={saving}
+ size="medium"
+ fullWidth
+ onChange={(value) => {
+ setCanvasId(value)
+ clearFieldError('canvasId')
+ }}
+ dataAttr="edit-canvas-app-widget-canvas"
+ />
+ </LemonField.Pure>
+ </section>
+ </div>
+ </LemonModal>
+ )
+}
+
+export function EditCanvasAppWidgetModal({
+ isOpen,
+ onClose,
+ config,
+ onSave,
+ name,
+ defaultTitle,
+ description,
+}: DashboardWidgetEditModalProps): JSX.Element | null {
+ if (!isOpen) {
+ return null
+ }
+
+ return (
+ <BindLogic
+ logic={editCanvasAppWidgetModalLogic}
+ props={{ onClose, config, onSave, name, defaultTitle, description }}
+ >
+ <EditCanvasAppWidgetModalContents />
+ </BindLogic>
+ )
+}
diff --git a/products/dashboards/frontend/widgets/canvas/canvasAppWidgetConfigValidation.ts b/products/dashboards/frontend/widgets/canvas/canvasAppWidgetConfigValidation.ts
new file mode 100644
index 000000000000..38b388281711
--- /dev/null
+++ b/products/dashboards/frontend/widgets/canvas/canvasAppWidgetConfigValidation.ts
@@ -0,0 +1,55 @@
+import { z } from 'zod'
+
+import { ApiError } from 'lib/api-error'
+
+import {
+ canvasAppWidgetConfigSchema,
+ canvasAppWidgetFormSchema,
+ type CanvasAppWidgetConfig,
+} from '../../generated/widget-configs.zod'
+import { fieldErrorsFromZodError, parseWidgetConfig } from '../widgetConfigValidation'
+
+type CanvasAppWidgetFormField = keyof z.infer<typeof canvasAppWidgetFormSchema>
+
+export type CanvasAppWidgetFieldErrors = Partial<Record<CanvasAppWidgetFormField, string>>
+
+export function parseCanvasAppWidgetConfig(config: Record<string, unknown>): CanvasAppWidgetConfig {
+ return parseWidgetConfig(canvasAppWidgetConfigSchema, config)
+}
+
+/** Set the selected canvas on an existing config, returning the full validated config. */
+export function patchCanvasAppWidgetConfig(
+ config: Record<string, unknown>,
+ canvasId: string | null
+): CanvasAppWidgetConfig {
+ const parsed = parseCanvasAppWidgetConfig(config)
+ return canvasAppWidgetConfigSchema.parse({ ...parsed, canvasId })
+}
+
+export function validateCanvasAppWidgetConfigInput(input: {
+ canvasId: string | null
+}): { success: true; config: CanvasAppWidgetConfig } | { success: false; fieldErrors: CanvasAppWidgetFieldErrors } {
+ const parsed = canvasAppWidgetFormSchema.safeParse({ canvasId: input.canvasId })
+
+ if (!parsed.success) {
+ return { success: false, fieldErrors: fieldErrorsFromZodError(parsed.error) }
+ }
+
+ return { success: true, config: canvasAppWidgetConfigSchema.parse(parsed.data) }
+}
+
+export function parseCanvasAppWidgetConfigApiError(
+ error: unknown,
+ config: Record<string, unknown>
+): CanvasAppWidgetFieldErrors | null {
+ if (!(error instanceof ApiError)) {
+ return null
+ }
+
+ const parsedConfig = canvasAppWidgetConfigSchema.safeParse(config)
+ if (parsedConfig.success) {
+ return null
+ }
+
+ return fieldErrorsFromZodError(parsedConfig.error)
+}
diff --git a/products/dashboards/frontend/widgets/canvas/canvasPickerLogic.test.ts b/products/dashboards/frontend/widgets/canvas/canvasPickerLogic.test.ts
new file mode 100644
index 000000000000..02f05c2a3cdc
--- /dev/null
+++ b/products/dashboards/frontend/widgets/canvas/canvasPickerLogic.test.ts
@@ -0,0 +1,47 @@
+import { waitFor } from '@testing-library/react'
+
+import { resumeKeaLoadersErrors, silenceKeaLoadersErrors } from '~/initKea'
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+
+import { canvasPickerLogic } from './canvasPickerLogic'
+
+const CANVAS_A = '0192f1c4-7b2e-7d3a-9f00-00000000000a'
+const CANVAS_B = '0192f1c4-7b2e-7d3a-9f00-00000000000b'
+
+describe('canvasPickerLogic', () => {
+ let logic: ReturnType<typeof canvasPickerLogic.build>
+
+ beforeEach(() => {
+ useMocks({
+ get: {
+ '/api/projects/:team_id/canvases/:id/': ({ params }) =>
+ params.id === CANVAS_B
+ ? [500, { detail: 'boom' }]
+ : [200, { id: params.id, name: `Canvas ${params.id}`, kind: 'freeform' }],
+ },
+ })
+ silenceKeaLoadersErrors()
+ initKeaTests()
+ })
+
+ afterEach(() => {
+ logic?.unmount()
+ resumeKeaLoadersErrors()
+ })
+
+ it('clears the selection error when the viewer picks back a canvas that already loaded', async () => {
+ logic = canvasPickerLogic({ pickerKey: 'modal' })
+ logic.mount()
+
+ logic.actions.ensureSelectedLoaded(CANVAS_A)
+ await waitFor(() => expect(logic.values.selectedCanvas?.id).toBe(CANVAS_A))
+
+ logic.actions.ensureSelectedLoaded(CANVAS_B)
+ await waitFor(() => expect(logic.values.selectedCanvasFailed).toBe(true))
+
+ logic.actions.ensureSelectedLoaded(CANVAS_A)
+ expect(logic.values.selectedCanvasFailed).toBe(false)
+ expect(logic.values.selectedCanvas?.id).toBe(CANVAS_A)
+ })
+})
diff --git a/products/dashboards/frontend/widgets/canvas/canvasPickerLogic.ts b/products/dashboards/frontend/widgets/canvas/canvasPickerLogic.ts
new file mode 100644
index 000000000000..383cf7208a0e
--- /dev/null
+++ b/products/dashboards/frontend/widgets/canvas/canvasPickerLogic.ts
@@ -0,0 +1,187 @@
+import { MakeLogicType, actions, connect, kea, key, listeners, path, props, reducers } from 'kea'
+import { loaders } from 'kea-loaders'
+
+import { teamLogic } from 'scenes/teamLogic'
+
+import { canvasesList, canvasesRetrieve } from 'products/canvas/frontend/generated/api'
+import type { CanvasApi } from 'products/canvas/frontend/generated/api.schemas'
+
+/** One page is plenty — search narrows the rest server-side, so we never paginate the dropdown. */
+const CANVAS_OPTIONS_LIMIT = 50
+const SEARCH_DEBOUNCE_MS = 300
+
+export type CanvasPickerLogicProps = { pickerKey: string }
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface canvasPickerLogicValues {
+ currentTeamIdStrict: number | string // teamLogic
+ canvasOptions: CanvasApi[]
+ canvasOptionsFailed: boolean
+ canvasOptionsLoading: boolean
+ hasLoadedOptions: boolean
+ search: string
+ selectedCanvas: CanvasApi | null
+ selectedCanvasFailed: boolean
+ selectedCanvasLoading: boolean
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface canvasPickerLogicActions {
+ ensureOptionsLoaded: () => {
+ value: true
+ }
+ ensureSelectedLoaded: (canvasId: string) => {
+ canvasId: string
+ }
+ loadOptions: ({ debounce }?: { debounce: boolean }) => {
+ debounce: boolean
+ }
+ loadOptionsFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ loadOptionsSuccess: (
+ canvasOptions: CanvasApi[],
+ payload?: {
+ debounce: boolean
+ }
+ ) => {
+ canvasOptions: CanvasApi[]
+ payload?: {
+ debounce: boolean
+ }
+ }
+ loadSelectedCanvas: ({ canvasId }: { canvasId: string }) => {
+ canvasId: string
+ }
+ loadSelectedCanvasFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ loadSelectedCanvasSuccess: (
+ selectedCanvas: CanvasApi,
+ payload?: {
+ canvasId: string
+ }
+ ) => {
+ selectedCanvas: CanvasApi
+ payload?: {
+ canvasId: string
+ }
+ }
+ retryLoadOptions: () => {
+ value: true
+ }
+ setSearch: (search: string) => {
+ search: string
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface canvasPickerLogicMeta {
+ key: string
+}
+
+export type canvasPickerLogicType = MakeLogicType<
+ canvasPickerLogicValues,
+ canvasPickerLogicActions,
+ CanvasPickerLogicProps,
+ canvasPickerLogicMeta
+>
+
+/** Lists the canvases the viewer can see, so a tile can only ever point at one they may open. */
+export const canvasPickerLogic = kea<canvasPickerLogicType>([
+ path((key) => ['products', 'dashboards', 'widgets', 'canvas', 'canvasPickerLogic', key]),
+ props({} as CanvasPickerLogicProps),
+ key((props) => props.pickerKey),
+
+ connect(() => ({
+ values: [teamLogic, ['currentTeamIdStrict']],
+ })),
+
+ actions({
+ setSearch: (search: string) => ({ search }),
+ ensureOptionsLoaded: true,
+ retryLoadOptions: true,
+ ensureSelectedLoaded: (canvasId: string) => ({ canvasId }),
+ }),
+
+ reducers({
+ search: ['', { setSearch: (_: string, { search }: { search: string }) => search }],
+ hasLoadedOptions: [false, { loadOptionsSuccess: () => true }],
+ canvasOptionsFailed: [false, { loadOptions: () => false, loadOptionsFailure: () => true }],
+ selectedCanvasFailed: [
+ false,
+ {
+ // Picking a canvas starts fresh, so an earlier failure cannot stick to a canvas that loaded fine.
+ ensureSelectedLoaded: () => false,
+ loadSelectedCanvas: () => false,
+ loadSelectedCanvasFailure: () => true,
+ },
+ ],
+ }),
+
+ loaders(({ values }) => ({
+ canvasOptions: [
+ [] as CanvasApi[],
+ {
+ loadOptions: async (
+ { debounce }: { debounce: boolean } = { debounce: false },
+ breakpoint
+ ): Promise<CanvasApi[]> => {
+ // Debounce keystroke-driven searches; the initial focus load should open the dropdown immediately.
+ if (debounce) {
+ await breakpoint(SEARCH_DEBOUNCE_MS)
+ }
+ const response = await canvasesList(String(values.currentTeamIdStrict), {
+ limit: CANVAS_OPTIONS_LIMIT,
+ // Only standalone apps belong on a dashboard; components are placed on grids, grids are homes.
+ kind: 'freeform',
+ ordering: '-updated_at',
+ search: values.search || undefined,
+ })
+ breakpoint()
+ return response.results ?? []
+ },
+ },
+ ],
+ selectedCanvas: [
+ null as CanvasApi | null,
+ {
+ loadSelectedCanvas: async ({ canvasId }: { canvasId: string }, breakpoint): Promise<CanvasApi> => {
+ const canvas = await canvasesRetrieve(String(values.currentTeamIdStrict), canvasId)
+ // A newer selection started its own request, so drop this stale response.
+ breakpoint()
+ return canvas
+ },
+ },
+ ],
+ })),
+
+ listeners(({ actions, values }) => ({
+ setSearch: () => {
+ actions.loadOptions({ debounce: true })
+ },
+ ensureOptionsLoaded: () => {
+ // Refocusing after a failed request retries it, even if an earlier request succeeded.
+ if ((!values.hasLoadedOptions || values.canvasOptionsFailed) && !values.canvasOptionsLoading) {
+ actions.loadOptions({ debounce: false })
+ }
+ },
+ retryLoadOptions: () => {
+ actions.loadOptions({ debounce: false })
+ },
+ ensureSelectedLoaded: ({ canvasId }) => {
+ if (values.selectedCanvas?.id === canvasId && !values.selectedCanvasLoading) {
+ return
+ }
+ actions.loadSelectedCanvas({ canvasId })
+ },
+ })),
+])
diff --git a/products/dashboards/frontend/widgets/canvas/editCanvasAppWidgetModalLogic.ts b/products/dashboards/frontend/widgets/canvas/editCanvasAppWidgetModalLogic.ts
new file mode 100644
index 000000000000..b755de14275c
--- /dev/null
+++ b/products/dashboards/frontend/widgets/canvas/editCanvasAppWidgetModalLogic.ts
@@ -0,0 +1,235 @@
+import { MakeLogicType, actions, defaults, kea, listeners, path, props, reducers, selectors } from 'kea'
+
+import { isWidgetConfigValidationError } from '../../utils'
+import {
+ widgetEditModalPropSelectors,
+ widgetEditModalTileActions,
+ buildWidgetTileMetadataPatch,
+ getWidgetEditModalTileDefaults,
+} from '../editWidgetModalBuilders'
+import type { DashboardWidgetEditModalProps } from '../registry'
+import {
+ parseCanvasAppWidgetConfig,
+ validateCanvasAppWidgetConfigInput,
+ type CanvasAppWidgetFieldErrors,
+} from './canvasAppWidgetConfigValidation'
+
+export type EditCanvasAppWidgetModalLogicProps = Omit<DashboardWidgetEditModalProps, 'isOpen'>
+
+type CanvasAppValidation = ReturnType<typeof validateCanvasAppWidgetConfigInput>
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface editCanvasAppWidgetModalLogicValues {
+ activeFieldErrors: CanvasAppWidgetFieldErrors
+ canvasId: string | null
+ defaultTitle: string
+ fieldErrors: CanvasAppWidgetFieldErrors
+ onClose: () => void
+ saveDisabledReason: string | undefined
+ saving: boolean
+ tileDescription: string
+ tileName: string
+ validation: CanvasAppValidation
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface editCanvasAppWidgetModalLogicActions {
+ clearFieldError: (field: keyof CanvasAppWidgetFieldErrors) => {
+ field: 'canvasId'
+ }
+ setCanvasId: (canvasId: string | null) => {
+ canvasId: string | null
+ }
+ setFieldErrors: (fieldErrors: CanvasAppWidgetFieldErrors) => {
+ fieldErrors: Partial<Record<'canvasId', string>>
+ }
+ setTileDescription: (tileDescription: string) => {
+ tileDescription: string
+ }
+ setTileName: (tileName: string) => {
+ tileName: string
+ }
+ submit: () => {
+ value: true
+ }
+ submitFailure: () => {
+ value: true
+ }
+ submitSuccess: () => {
+ value: true
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface editCanvasAppWidgetModalLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ validation: (canvasId: string | null) => CanvasAppValidation
+ activeFieldErrors: (
+ validation:
+ | {
+ fieldErrors: CanvasAppWidgetFieldErrors
+ success: false
+ }
+ | {
+ config: import('../../generated/widget-configs.zod').CanvasAppWidgetConfig
+ success: true
+ },
+ fieldErrors: Partial<Record<'canvasId', string>>
+ ) => CanvasAppWidgetFieldErrors
+ saveDisabledReason: (
+ saving: boolean,
+ validation:
+ | {
+ fieldErrors: CanvasAppWidgetFieldErrors
+ success: false
+ }
+ | {
+ config: import('../../generated/widget-configs.zod').CanvasAppWidgetConfig
+ success: true
+ }
+ ) => string | undefined
+ }
+}
+
+export type editCanvasAppWidgetModalLogicType = MakeLogicType<
+ editCanvasAppWidgetModalLogicValues,
+ editCanvasAppWidgetModalLogicActions,
+ EditCanvasAppWidgetModalLogicProps,
+ editCanvasAppWidgetModalLogicMeta
+>
+
+export const editCanvasAppWidgetModalLogic = kea<editCanvasAppWidgetModalLogicType>([
+ path(['products', 'dashboards', 'widgets', 'canvas', 'editCanvasAppWidgetModalLogic']),
+
+ props({
+ config: {},
+ onSave: async () => {},
+ onClose: () => {},
+ name: '',
+ defaultTitle: 'Untitled',
+ description: '',
+ } as EditCanvasAppWidgetModalLogicProps),
+
+ actions({
+ ...widgetEditModalTileActions,
+ setCanvasId: (canvasId: string | null) => ({ canvasId }),
+ setFieldErrors: (fieldErrors: CanvasAppWidgetFieldErrors) => ({ fieldErrors }),
+ clearFieldError: (field: keyof CanvasAppWidgetFieldErrors) => ({ field }),
+ submit: true,
+ submitSuccess: true,
+ submitFailure: true,
+ }),
+
+ reducers({
+ canvasId: [
+ null as string | null,
+ {
+ setCanvasId: (_: string | null, { canvasId }: { canvasId: string | null }) => canvasId,
+ },
+ ],
+ tileName: [
+ '',
+ {
+ setTileName: (_: string, { tileName }: { tileName: string }) => tileName,
+ },
+ ],
+ tileDescription: [
+ '',
+ {
+ setTileDescription: (_: string, { tileDescription }: { tileDescription: string }) => tileDescription,
+ },
+ ],
+ fieldErrors: [
+ {} as CanvasAppWidgetFieldErrors,
+ {
+ setFieldErrors: (
+ _: CanvasAppWidgetFieldErrors,
+ { fieldErrors }: { fieldErrors: CanvasAppWidgetFieldErrors }
+ ) => fieldErrors,
+ clearFieldError: (
+ state: CanvasAppWidgetFieldErrors,
+ { field }: { field: keyof CanvasAppWidgetFieldErrors }
+ ) => {
+ if (!state[field]) {
+ return state
+ }
+ const next = { ...state }
+ delete next[field]
+ return next
+ },
+ },
+ ],
+ saving: [
+ false,
+ {
+ submit: (_state: boolean, _payload: { value: true }) => true,
+ submitSuccess: (_state: boolean, _payload: { value: true }) => false,
+ submitFailure: (_state: boolean, _payload: { value: true }) => false,
+ },
+ ],
+ }),
+
+ selectors({
+ ...widgetEditModalPropSelectors,
+ validation: [
+ (s) => [s.canvasId],
+ (canvasId: string | null): CanvasAppValidation => validateCanvasAppWidgetConfigInput({ canvasId }),
+ ],
+ activeFieldErrors: [
+ (s) => [s.validation, s.fieldErrors],
+ (validation: CanvasAppValidation, fieldErrors: CanvasAppWidgetFieldErrors): CanvasAppWidgetFieldErrors => {
+ if (!validation.success) {
+ return { ...validation.fieldErrors, ...fieldErrors }
+ }
+ return fieldErrors
+ },
+ ],
+ saveDisabledReason: [
+ (s) => [s.saving, s.validation],
+ (saving: boolean, validation: CanvasAppValidation): string | undefined => {
+ if (saving) {
+ return 'Saving…'
+ }
+ if (!validation.success) {
+ return 'Fix validation errors to save'
+ }
+ return undefined
+ },
+ ],
+ }),
+
+ defaults(({ props }) => ({
+ canvasId: parseCanvasAppWidgetConfig(props.config).canvasId ?? null,
+ ...getWidgetEditModalTileDefaults(props),
+ fieldErrors: {},
+ saving: false,
+ })),
+
+ listeners(({ actions, props, values }) => ({
+ submit: async () => {
+ const result = values.validation
+
+ if (!result.success) {
+ actions.setFieldErrors(result.fieldErrors)
+ return
+ }
+
+ try {
+ await props.onSave(
+ result.config,
+ buildWidgetTileMetadataPatch(props, values.tileName, values.tileDescription)
+ )
+ actions.setFieldErrors({})
+ props.onClose()
+ actions.submitSuccess()
+ } catch (error) {
+ actions.submitFailure()
+ if (isWidgetConfigValidationError(error)) {
+ actions.setFieldErrors(error.fieldErrors as CanvasAppWidgetFieldErrors)
+ return
+ }
+ throw error
+ }
+ },
+ })),
+])