: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
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.ymlindex cc118ed2c9f7..8409f6b07c5e 100644--- a/frontend/snapshots.yml+++ b/frontend/snapshots.yml@@ -6870,6 +6870,14 @@ snapshots:hash: v1.k794b7964.9572c4979a6934a94886531af0d64845148e3417b98fe8010c677420bbd1f3b7.zdaJR_5DwY5IX5qeFfu9O2I6VajkSqqv9XU46z8HcMQproducts-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-Aproducts-dashboards-dashboard-widgets-widget-types-error-tracking-top-issues--default--dark:hash: v1.k794b7964.0c5e48132f055382561335fea973ddf546cf7216ce997c00e4c5d871838bbb1f.ALpVMICEU6x_cD5zCzaVXJBuqGqjWXHVTivfn-jrmikproducts-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.tsindex 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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+ }+ },+ })),+])