@fugood/bricks-project 2.25.0-beta.4 → 2.25.0-beta.40

package/tools/push-config.ts

@@ -0,0 +1,118 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { parseArgs } from 'util'
+import { sh } from './_shell'
+import { buildCommitArgs } from './_git-author'
+import { writeLastPushedCommit } from './_last-pushed-commit'
+
+const cwd = process.cwd()
+
+const readJson = async (p: string) => JSON.parse(await readFile(p, 'utf8'))
+
+const {
+  values: { 'auto-commit': autoCommit, 'no-check': noCheck, 'no-validate': noValidate, yes, help },
+} = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    'auto-commit': { type: 'boolean' },
+    'no-check': { type: 'boolean' },
+    'no-validate': { type: 'boolean' },
+    yes: { type: 'boolean', short: 'y' },
+    help: { type: 'boolean', short: 'h' },
+  },
+  allowPositionals: true,
+})
+
+if (help) {
+  console.log(`Push compiled config to BRICKS without creating a release.
+
+Options:
+  --auto-commit              Auto-commit unstaged changes before pushing
+  --no-check                 Skip the conflict guard (don't pass --last-commit-id)
+  --no-validate              Skip server-side config schema validation
+  -y, --yes                  Skip all prompts
+  -h, --help                 Show this help message`)
+  process.exit(0)
+}
+
+// Detect git repo (mirrors deploy.ts)
+const { exitCode } = await sh`cd ${cwd} && git status`.quiet().nothrow()
+const isGitRepo = exitCode === 0
+
+if (!isGitRepo && !yes) {
+  const confirmContinue = prompt('No git repository found, continue? (y/n)')
+  if (confirmContinue !== 'y') throw new Error('Update cancelled')
+}
+
+// Read application.json + compiled config
+const app = await readJson(`${cwd}/application.json`)
+const config = await readJson(`${cwd}/.bricks/build/application-config.json`)
+
+// Handle unstaged changes the same way deploy.ts does.
+let commitId = ''
+let parentCommitId = ''
+if (isGitRepo) {
+  const unstagedChanges = await sh`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
+  if (unstagedChanges) {
+    if (autoCommit) {
+      // Capture the pre-commit HEAD so we can use it as the conflict-check
+      // baseline (the server should still hold it from the prior deploy).
+      parentCommitId = (await sh`cd ${cwd} && git rev-parse HEAD`.nothrow().text()).trim()
+      await sh`cd ${cwd} && git add -A`
+      const commitArgs = await buildCommitArgs(cwd, ['chore: update bricks config'])
+      await sh`cd ${cwd} && git ${commitArgs}`
+    } else {
+      throw new Error('Unstaged changes found, please commit or stash your changes before updating')
+    }
+  }
+  commitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
+}
+
+// Auto-derive --last-commit-id for the server-side conflict guard.
+//   - parent of the auto-commit (server still holds it from the prior deploy)
+//   - current HEAD (clean tree — server should be at the same commit too)
+let lastCommitId: string | undefined
+if (!noCheck) {
+  if (parentCommitId) lastCommitId = parentCommitId
+  else if (commitId) lastCommitId = commitId
+}
+
+if (!yes) {
+  const confirm = prompt('Are you sure you want to push the new config? (y/n)')
+  if (confirm !== 'y') throw new Error('Update cancelled')
+}
+
+const isModule = app.type === 'module'
+const command = isModule ? 'module' : 'app'
+
+const updateConfig = {
+  ...config,
+  bricks_project_last_commit_id: commitId || undefined,
+}
+const configPath = `${cwd}/.bricks/build/push-config.json`
+await writeFile(configPath, JSON.stringify(updateConfig))
+
+const args = ['bricks', command, 'update', app.id, '-f', configPath, '--json']
+if (noValidate) args.push('--no-validate')
+if (lastCommitId) args.push('--last-commit-id', lastCommitId)
+
+const result = await sh`${args}`.quiet().nothrow()
+
+if (result.exitCode !== 0) {
+  const output = result.stderr.toString() || result.stdout.toString()
+  try {
+    const json = JSON.parse(output)
+    throw new Error(json.error?.message || json.error || 'Update failed')
+  } catch {
+    throw new Error(output || 'Update failed')
+  }
+}
+
+const output = JSON.parse(result.stdout.toString())
+
+// Record the commit we just pushed from so a later pull can use it as the
+// merge base regardless of what the server stores in
+// bricks_project_last_commit_id (which may be an opaque nanoid for
+// content-only edits).
+if (commitId) await writeLastPushedCommit(cwd, commitId)
+
+console.log(`${isModule ? 'Module' : 'App'} config updated: ${output.target?.name || app.name}`)

package/tools/{preview-main.mjs → simulator-main.mjs}

@@ -1,11 +1,19 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
-import { app, BrowserWindow } from 'electron'
-import { readFile, writeFile } from 'fs/promises'
+import { app, BrowserWindow, ipcMain } from 'electron'
+import { mkdir, readdir, readFile, rm, writeFile } from 'fs/promises'
 import { watchFile } from 'fs'
 import { createServer } from 'http'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { parseArgs } from 'util'
 import * as TOON from '@toon-format/toon'
 
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on('error', (err) => {
+    if (err.code !== 'EPIPE') throw err
+  })
+}
+
 const { values } = parseArgs({
   args: process.argv,
   options: {
@@ -22,6 +30,139 @@ const { values } = parseArgs({
 })
 
 const cwd = process.cwd()
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const AUTOMATION_SCREENSHOT_PROJECT_DIR = path.join('.bricks', 'automation_screenshots')
+const DEFAULT_SIMULATOR_SECURITY_SETTINGS = Object.freeze({
+  allowedInsecureHosts: [],
+})
+
+const isObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value)
+
+const resolveAutomationScreenshotPath = (requestedPath = '') => {
+  const baseDir = path.resolve(cwd, AUTOMATION_SCREENSHOT_PROJECT_DIR)
+  const raw = String(requestedPath || AUTOMATION_SCREENSHOT_PROJECT_DIR)
+  const fromProject = path.resolve(cwd, raw)
+  const target =
+    fromProject === baseDir || fromProject.startsWith(`${baseDir}${path.sep}`)
+      ? fromProject
+      : path.resolve(baseDir, raw)
+
+  if (target !== baseDir && !target.startsWith(`${baseDir}${path.sep}`)) {
+    throw new Error('Automation screenshot path must stay inside the project screenshot directory.')
+  }
+  return target
+}
+
+const normalizeAutomationScreenshotEncoding = (encoding) =>
+  encoding === 'base64' ? 'base64' : 'utf8'
+
+const registerAutomationScreenshotIpc = () => {
+  ipcMain.handle('bricks-automation-screenshots:exists', async (_event, filePath) => {
+    try {
+      await readFile(resolveAutomationScreenshotPath(filePath))
+      return true
+    } catch {
+      return false
+    }
+  })
+  ipcMain.handle('bricks-automation-screenshots:readdir', async (_event, dirPath) => {
+    try {
+      return await readdir(resolveAutomationScreenshotPath(dirPath))
+    } catch {
+      return []
+    }
+  })
+  ipcMain.handle('bricks-automation-screenshots:mkdir', async (_event, dirPath) => {
+    await mkdir(resolveAutomationScreenshotPath(dirPath), { recursive: true })
+  })
+  ipcMain.handle('bricks-automation-screenshots:unlink', async (_event, filePath) => {
+    await rm(resolveAutomationScreenshotPath(filePath), { recursive: true, force: true })
+  })
+  ipcMain.handle('bricks-automation-screenshots:read-file', async (_event, filePath, encoding) =>
+    readFile(
+      resolveAutomationScreenshotPath(filePath),
+      normalizeAutomationScreenshotEncoding(encoding),
+    ),
+  )
+  ipcMain.handle(
+    'bricks-automation-screenshots:write-file',
+    async (_event, filePath, contents, encoding) => {
+      const target = resolveAutomationScreenshotPath(filePath)
+      await mkdir(path.dirname(target), { recursive: true })
+      await writeFile(target, contents, normalizeAutomationScreenshotEncoding(encoding))
+    },
+  )
+}
+
+const normalizeSimulatorSecuritySettings = (settings = {}) => {
+  const source = isObject(settings) ? settings : {}
+  const allowedHosts = Array.isArray(source.allowedInsecureHosts)
+    ? source.allowedInsecureHosts
+    : DEFAULT_SIMULATOR_SECURITY_SETTINGS.allowedInsecureHosts
+
+  return {
+    allowedInsecureHosts: allowedHosts
+      .filter((host) => typeof host === 'string')
+      .map((host) => host.trim().toLowerCase())
+      .filter(Boolean),
+  }
+}
+
+const normalizeAllowedConnection = (value) => {
+  const raw = String(value || '')
+    .trim()
+    .toLowerCase()
+  if (!raw) return null
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) return { host: raw, protocol: null }
+  try {
+    const url = new URL(raw)
+    return {
+      host: url.host.toLowerCase(),
+      protocol: url.protocol,
+    }
+  } catch {
+    return null
+  }
+}
+
+const shouldBlockInsecureConnection = (rawUrl, settings = {}) => {
+  const normalized = normalizeSimulatorSecuritySettings(settings)
+
+  try {
+    const url = new URL(String(rawUrl || ''))
+    if (url.protocol !== 'http:' && url.protocol !== 'ws:') return false
+    const host = url.host.toLowerCase()
+    const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, '')
+    return !normalized.allowedInsecureHosts.some((allowedHost) => {
+      const allowed = normalizeAllowedConnection(allowedHost)
+      if (!allowed) return false
+      if (allowed.protocol && allowed.protocol !== url.protocol) return false
+      return allowed.host === host || allowed.host === hostname
+    })
+  } catch {
+    return false
+  }
+}
+
+const getUnsecureConnectionHost = (rawUrl) => {
+  try {
+    const url = new URL(String(rawUrl || ''))
+    if (url.protocol !== 'http:' && url.protocol !== 'ws:') return null
+    return url.host.toLowerCase()
+  } catch {
+    return null
+  }
+}
+
+const readSimulatorProjectSettings = async () => {
+  try {
+    return normalizeSimulatorSecuritySettings(
+      JSON.parse(await readFile(`${cwd}/simulator.json`, 'utf8')),
+    )
+  } catch {
+    return normalizeSimulatorSecuritySettings()
+  }
+}
 
 let takeScreenshotConfig = null
 try {
@@ -39,6 +180,7 @@ try {
 }
 
 let config = JSON.parse(await readFile(`${cwd}/.bricks/build/application-config.json`))
+let simulatorSettings = await readSimulatorProjectSettings()
 
 // Resolve testId from testTitleLike
 let testId = values['test-id'] || null
@@ -71,6 +213,13 @@ const previewUrlMap = {
 
 const previewUrl = previewUrlMap[stage]
 if (!previewUrl) throw new Error(`Invalid BRICKS_STAGE: ${stage}`)
+simulatorSettings = normalizeSimulatorSecuritySettings({
+  ...simulatorSettings,
+  allowedInsecureHosts: [
+    ...simulatorSettings.allowedInsecureHosts,
+    getUnsecureConnectionHost(previewUrl),
+  ].filter(Boolean),
+})
 
 // --- CDP WebSocket Server ---
 // Bridges external CDP clients to the preview's postMessage-based CDP bridge.
@@ -136,9 +285,9 @@ const startCdpServer = async (mainWindow, port) => {
       res.end(
         JSON.stringify([
           {
-            description: 'BRICKS Preview (CTOR Preview)',
-            id: 'bricks-preview',
-            title: 'BRICKS Preview',
+            description: 'BRICKS Simulator',
+            id: 'bricks-simulator',
+            title: 'BRICKS Simulator',
             type: 'page',
             url: previewUrl,
             webSocketDebuggerUrl: `ws://localhost:${actualPort}/ws`,
@@ -149,7 +298,7 @@ const startCdpServer = async (mainWindow, port) => {
     }
     if (req.url === '/json/version') {
       res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(JSON.stringify({ Browser: 'BRICKS Preview', 'Protocol-Version': '1.3' }))
+      res.end(JSON.stringify({ Browser: 'BRICKS Simulator', 'Protocol-Version': '1.3' }))
       return
     }
     // bricks-cli discovery endpoint
@@ -157,7 +306,7 @@ const startCdpServer = async (mainWindow, port) => {
       res.writeHead(200, { 'Content-Type': 'application/json' })
       res.end(
         JSON.stringify({
-          name: 'BRICKS Preview',
+          name: 'BRICKS Simulator',
           port: actualPort,
           protocols: ['cdp'],
           hasPasscode: false,
@@ -200,6 +349,7 @@ const startCdpServer = async (mainWindow, port) => {
 }
 
 app.on('ready', () => {
+  registerAutomationScreenshotIpc()
   let show = true
   if (takeScreenshotConfig && !takeScreenshotConfig.noHeadless) show = false
   const mainWindow = new BrowserWindow({
@@ -207,8 +357,19 @@ app.on('ready', () => {
     height: takeScreenshotConfig?.height || 768,
     frame: !takeScreenshotConfig,
     show,
+    webPreferences: {
+      preload: path.join(__dirname, 'simulator-preload.cjs'),
+      contextIsolation: true,
+      nodeIntegration: false,
+    },
   })
   mainWindow.setBackgroundColor('#333')
+  mainWindow.webContents.session.webRequest.onBeforeRequest(
+    { urls: ['http://*/*', 'ws://*/*'] },
+    (details, callback) => {
+      callback({ cancel: shouldBlockInsecureConnection(details.url, simulatorSettings) })
+    },
+  )
   mainWindow.loadURL(previewUrl)
 
   const sendConfig = () => {
@@ -224,16 +385,23 @@ app.on('ready', () => {
     )
     if (takeScreenshotConfig) {
       const { delay, width, height, path } = takeScreenshotConfig
-      setTimeout(() => {
+      setTimeout(async () => {
+        let screenshotFailed = false
         console.log('Taking screenshot')
-        mainWindow.webContents.capturePage().then((image) => {
+        try {
+          const image = await mainWindow.webContents.capturePage()
           console.log('Writing screenshot to', path)
-          writeFile(path, image.resize({ width, height }).toJPEG(75))
+          await writeFile(path, image.resize({ width, height }).toJPEG(75))
+        } catch (err) {
+          screenshotFailed = true
+          console.error('Screenshot capture/write failed', err)
+        } finally {
           if (noKeepOpen) {
             console.log('Closing app')
-            app.quit()
+            if (screenshotFailed) app.exit(1)
+            else app.quit()
           }
-        })
+        }
       }, delay)
     }
   }
@@ -287,7 +455,34 @@ app.on('ready', () => {
     async () => {
       console.log('Detected config changed')
       config = JSON.parse(await readFile(`${cwd}/.bricks/build/application-config.json`))
+      const nextSimulatorSettings = await readSimulatorProjectSettings()
+      simulatorSettings = normalizeSimulatorSecuritySettings({
+        ...nextSimulatorSettings,
+        allowedInsecureHosts: [
+          ...nextSimulatorSettings.allowedInsecureHosts,
+          getUnsecureConnectionHost(previewUrl),
+        ].filter(Boolean),
+      })
       sendConfig()
     },
   )
+  watchFile(
+    `${cwd}/simulator.json`,
+    {
+      bigint: false,
+      persistent: true,
+      interval: 1000,
+    },
+    async () => {
+      console.log('Detected simulator settings changed')
+      const nextSimulatorSettings = await readSimulatorProjectSettings()
+      simulatorSettings = normalizeSimulatorSecuritySettings({
+        ...nextSimulatorSettings,
+        allowedInsecureHosts: [
+          ...nextSimulatorSettings.allowedInsecureHosts,
+          getUnsecureConnectionHost(previewUrl),
+        ].filter(Boolean),
+      })
+    },
+  )
 })

package/tools/simulator-preload.cjs

@@ -0,0 +1,16 @@
+const { contextBridge, ipcRenderer } = require('electron')
+
+const AUTOMATION_SCREENSHOT_ROOT = '.bricks/automation_screenshots'
+
+contextBridge.exposeInMainWorld('BRICKS_AUTOMATION_SCREENSHOTS', {
+  rootDir: AUTOMATION_SCREENSHOT_ROOT,
+  exists: (filePath) => ipcRenderer.invoke('bricks-automation-screenshots:exists', filePath),
+  readdir: (dirPath) => ipcRenderer.invoke('bricks-automation-screenshots:readdir', dirPath),
+  readDir: (dirPath) => ipcRenderer.invoke('bricks-automation-screenshots:readdir', dirPath),
+  mkdir: (dirPath) => ipcRenderer.invoke('bricks-automation-screenshots:mkdir', dirPath),
+  unlink: (filePath) => ipcRenderer.invoke('bricks-automation-screenshots:unlink', filePath),
+  readFile: (filePath, encoding) =>
+    ipcRenderer.invoke('bricks-automation-screenshots:read-file', filePath, encoding),
+  writeFile: (filePath, contents, encoding) =>
+    ipcRenderer.invoke('bricks-automation-screenshots:write-file', filePath, contents, encoding),
+})

package/tools/{preview.ts → simulator.ts}

@@ -98,7 +98,7 @@ const cleanupDevtoolsInfo = () => {
   } catch {}
 }
 
-// Kill existing preview process if devtools.json contains a stale pid
+// Kill existing simulator process if devtools.json contains a stale pid
 try {
   const devtoolsInfo = JSON.parse(await readFile(devtoolsInfoPath, 'utf8'))
   if (devtoolsInfo.pid) {
@@ -111,7 +111,7 @@ try {
 
 const proc = spawn(
   'bunx',
-  ['--bun', 'electron', `${import.meta.dirname}/preview-main.mjs`, ...args],
+  ['--bun', 'electron', `${import.meta.dirname}/simulator-main.mjs`, ...args],
   {
     env: { ...process.env, BRICKS_STAGE: app.stage || 'production' },
     stdio: ['inherit', 'pipe', 'inherit'],
@@ -127,14 +127,14 @@ rl.on('line', (line) => {
     return
   }
   if (!line) return
-  // Detect CDP server startup from preview-main output
+  // Detect CDP server startup from simulator-main output
   const cdpMatch = line.match(/^CDP server: ws:\/\/localhost:(\d+)/)
   if (cdpMatch) {
     const info = {
       port: parseInt(cdpMatch[1], 10),
       pid: proc.pid,
       address: 'localhost',
-      name: `${app.name || 'Unnamed'} (CTOR Preview)`,
+      name: `${app.name || 'Unnamed'} (CTOR Simulator)`,
       startedAt: new Date().toISOString(),
     }
     writeFile(devtoolsInfoPath, JSON.stringify(info, null, 2))

package/types/{animation.ts → animation.d.ts}

@@ -44,10 +44,21 @@ export interface AnimationTimingConfig {
 export interface AnimationSpringConfig {
   __type: 'AnimationSpringConfig'
   toValue: number // BRICKS Grid unit
-  friction: number
-  tension: number
-  speed: number
-  bounciness: number
+  // Use one spring parameter family: tension/friction, speed/bounciness,
+  // or stiffness/damping/mass.
+  friction?: number
+  tension?: number
+  speed?: number
+  bounciness?: number
+  stiffness?: number
+  damping?: number
+  mass?: number
+  velocity?: number
+  delay?: number
+  isInteraction?: boolean
+  overshootClamping?: boolean
+  restDisplacementThreshold?: number
+  restSpeedThreshold?: number
 }
 
 export interface AnimationDecayConfig {
@@ -62,7 +73,7 @@ export interface AnimationDef {
   __typename: 'Animation'
   id: string
   alias?: string
-  title: string
+  title?: string
   description?: string
   hideShortRef?: boolean
   runType?: 'once' | 'loop'
@@ -93,8 +104,13 @@ export interface AnimationComposeDef {
 
 export type Animation = AnimationDef | AnimationComposeDef
 
+// Animation event handlers accept either a direct Animation or a getter that
+// returns one. The getter form is useful for lazy/forward references between
+// animations defined across files.
+export type AnimationOrGetter = Animation | (() => Animation)
+
 export interface AnimationBasicEvents {
-  showStart?: Animation
-  standby?: Animation
-  breatheStart?: Animation
+  showStart?: AnimationOrGetter
+  standby?: AnimationOrGetter
+  breatheStart?: AnimationOrGetter
 }

package/types/{automation.ts → automation.d.ts}

@@ -83,9 +83,22 @@ export type TestMethodName =
   | 'delay'
 
 /**
- * Run array types for each test method
- * Each method has a specific signature: [methodName, ...args]
+ * Union type for all test method run arrays
  */
+export type TestMethodRun =
+  | TestMethodRunBrickPress
+  | TestMethodRunBrickExists
+  | TestMethodRunWaitUntilBrickExists
+  | TestMethodRunWaitUntilEventTrigger
+  | TestMethodRunWaitUntilCanvasChange
+  | TestMethodRunKeydown
+  | TestMethodRunKeyup
+  | TestMethodRunHttpRequest
+  | TestMethodRunAssertProperty
+  | TestMethodRunWaitUntilPropertyChange
+  | TestMethodRunExecuteAction
+  | TestMethodRunMatchScreenshot
+  | TestMethodRunDelay
 
 // [methodName, subspaceId, brickId, options?]
 export type TestMethodRunBrickPress = ['brick_press', SubspaceRef, BrickRef, Record<string, any>?]
@@ -157,24 +170,6 @@ export type TestMethodRunMatchScreenshot = ['match_screenshot', string, number?,
 // [methodName, subspaceId?, propertyId?, defaultValue?]
 export type TestMethodRunDelay = ['delay', SubspaceRef?, DataRef?, number?]
 
-/**
- * Union type for all test method run arrays
- */
-export type TestMethodRun =
-  | TestMethodRunBrickPress
-  | TestMethodRunBrickExists
-  | TestMethodRunWaitUntilBrickExists
-  | TestMethodRunWaitUntilEventTrigger
-  | TestMethodRunWaitUntilCanvasChange
-  | TestMethodRunKeydown
-  | TestMethodRunKeyup
-  | TestMethodRunHttpRequest
-  | TestMethodRunAssertProperty
-  | TestMethodRunWaitUntilPropertyChange
-  | TestMethodRunExecuteAction
-  | TestMethodRunMatchScreenshot
-  | TestMethodRunDelay
-
 /**
  * Test case definition
  */
@@ -203,6 +198,7 @@ export type LocalSyncMode = 'main-only' | 'minor-only'
 export interface AutomationTest {
   __typename: 'AutomationTest'
   id: string
+  alias?: string
   title: string
   hideShortRef?: boolean
   timeout: number

package/types/{brick-base.ts → brick-base.d.ts}

@@ -1,7 +1,7 @@
 /* Auto generated by build script */
 import type { SwitchCondInnerStateCurrentCanvas, SwitchCondData, SwitchDef } from './switch'
 import type { Data, DataLink } from './data'
-import type { Animation, AnimationBasicEvents } from './animation'
+import type { Animation, AnimationBasicEvents, AnimationOrGetter } from './animation'
 import type {
   Brick,
   EventAction,

package/types/bricks/{Camera.ts → Camera.d.ts}

@@ -4,7 +4,7 @@
  */
 import type { SwitchCondInnerStateCurrentCanvas, SwitchCondData, SwitchDef } from '../switch'
 import type { Data, DataLink } from '../data'
-import type { Animation, AnimationBasicEvents } from '../animation'
+import type { Animation, AnimationBasicEvents, AnimationOrGetter } from '../animation'
 import type {
   Brick,
   EventAction,
@@ -213,13 +213,13 @@ Default property:
     faceDetected?: () => Data<Array<{ [key: string]: any }>>
   }
   animation?: AnimationBasicEvents & {
-    stateChange?: Animation
-    recordStart?: Animation
-    recordEnd?: Animation
-    barcodeRead?: Animation
-    pictureTaken?: Animation
-    recordFinish?: Animation
-    mountError?: Animation
+    stateChange?: AnimationOrGetter
+    recordStart?: AnimationOrGetter
+    recordEnd?: AnimationOrGetter
+    barcodeRead?: AnimationOrGetter
+    pictureTaken?: AnimationOrGetter
+    recordFinish?: AnimationOrGetter
+    mountError?: AnimationOrGetter
   }
 }
 

package/types/bricks/{Chart.ts → Chart.d.ts}

@@ -4,7 +4,7 @@
  */
 import type { SwitchCondInnerStateCurrentCanvas, SwitchCondData, SwitchDef } from '../switch'
 import type { Data, DataLink } from '../data'
-import type { Animation, AnimationBasicEvents } from '../animation'
+import type { Animation, AnimationBasicEvents, AnimationOrGetter } from '../animation'
 import type {
   Brick,
   EventAction,
@@ -343,9 +343,9 @@ Default property:
     >
   }
   animation?: AnimationBasicEvents & {
-    onRender?: Animation
-    onPress?: Animation
-    onLegendSelectChanged?: Animation
+    onRender?: AnimationOrGetter
+    onPress?: AnimationOrGetter
+    onLegendSelectChanged?: AnimationOrGetter
   }
 }