@fugood/bricks-ctor 2.25.0-beta.6 → 2.25.0-beta.8

package/compile/__tests__/index.test.js

@@ -0,0 +1,115 @@
+import { compile } from '../index'
+
+const SUBSPACE_ID = 'SUBSPACE_00000000-0000-0000-0000-000000000001'
+const CANVAS_ID = 'CANVAS_00000000-0000-0000-0000-000000000001'
+const ANIMATION_ID = 'ANIMATION_00000000-0000-0000-0000-000000000001'
+
+const makeApp = (animations) => {
+  const rootCanvas = {
+    __typename: 'Canvas',
+    id: CANVAS_ID,
+    items: [],
+  }
+  const rootSubspace = {
+    __typename: 'Subspace',
+    id: SUBSPACE_ID,
+    title: 'Main Subspace',
+    layout: {
+      width: 96,
+      height: 54,
+    },
+    rootCanvas,
+    canvases: [rootCanvas],
+    animations,
+    bricks: [],
+    generators: [],
+    data: [],
+    dataRouting: [],
+    dataCalculation: [],
+  }
+
+  return {
+    name: 'Compile animation test',
+    rootSubspace,
+    subspaces: [rootSubspace],
+  }
+}
+
+describe('compile animations', () => {
+  test('normalizes mixed legacy spring config', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const config = await compile(
+        makeApp([
+          {
+            __typename: 'Animation',
+            id: ANIMATION_ID,
+            alias: 'btnPressOut',
+            title: 'Button Press Out',
+            property: 'transform.scale',
+            config: {
+              __type: 'AnimationSpringConfig',
+              toValue: 1,
+              friction: 5,
+              tension: 200,
+              speed: 14,
+              bounciness: 8,
+            },
+          },
+        ]),
+      )
+
+      expect(config.subspace_map[SUBSPACE_ID].animation_map[ANIMATION_ID].config).toEqual({
+        toValue: 1,
+        friction: 5,
+        tension: 200,
+      })
+      const warning = warnSpy.mock.calls[0][0]
+      expect(warning).toContain('Resolved animation spring config')
+      expect(warning).toContain('Button Press Out')
+      expect(warning).toContain('btnPressOut')
+      expect(warning).toContain('transform.scale')
+      expect(warning).toContain('Main Subspace')
+      expect(warning).not.toContain('ANIMATION_')
+      expect(warning).not.toContain('SUBSPACE_')
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+
+  test('rejects invalid animation property', async () => {
+    await expect(
+      compile(
+        makeApp([
+          {
+            __typename: 'Animation',
+            id: ANIMATION_ID,
+            property: 'transform.skewX',
+            config: {
+              __type: 'AnimationTimingConfig',
+              toValue: 1,
+            },
+          },
+        ]),
+      ),
+    ).rejects.toThrow(/Invalid animation property/)
+  })
+
+  test('rejects invalid animation config type', async () => {
+    await expect(
+      compile(
+        makeApp([
+          {
+            __typename: 'Animation',
+            id: ANIMATION_ID,
+            property: 'opacity',
+            config: {
+              __type: 'AnimationUnknownConfig',
+              toValue: 1,
+            },
+          },
+        ]),
+      ),
+    ).rejects.toThrow(/Invalid animation config type/)
+  })
+})

package/compile/index.ts

@@ -301,6 +301,162 @@ const animationTypeMap = {
   AnimationTimingConfig: 'timing',
   AnimationSpringConfig: 'spring',
   AnimationDecayConfig: 'decay',
+} as const
+
+type CompiledAnimationType = (typeof animationTypeMap)[keyof typeof animationTypeMap]
+type WarningMetadata = Record<string, unknown>
+
+const animationProperties = new Set([
+  'transform.translateX',
+  'transform.translateY',
+  'transform.scale',
+  'transform.scaleX',
+  'transform.scaleY',
+  'transform.rotate',
+  'transform.rotateX',
+  'transform.rotateY',
+  'opacity',
+])
+
+const animationComposeTypes = new Set(['parallel', 'sequence'])
+const springConfigFamilies = [
+  ['stiffness', 'damping', 'mass'],
+  ['tension', 'friction'],
+  ['bounciness', 'speed'],
+]
+const springConfigFamilyKeys = new Set(springConfigFamilies.flat())
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+
+const hasDefinedConfigValue = (config: Record<string, unknown>, key: string) =>
+  config[key] !== undefined
+
+const assertConfigValue = (
+  config: Record<string, unknown>,
+  key: string,
+  errorReference: string,
+) => {
+  if (!hasDefinedConfigValue(config, key)) {
+    throw new Error(`Invalid animation config ${errorReference}: missing "${key}"`)
+  }
+}
+
+const assertAnimationProperty = (property: unknown, errorReference: string) => {
+  if (typeof property !== 'string' || !animationProperties.has(property)) {
+    throw new Error(
+      `Invalid animation property${errorReference ? ` ${errorReference}` : ''}: ${String(
+        property,
+      )}`,
+    )
+  }
+  return property
+}
+
+const getAnimationType = (config: unknown, errorReference: string): CompiledAnimationType => {
+  if (!isRecord(config)) {
+    throw new Error(`Invalid animation config ${errorReference}: config must be an object`)
+  }
+
+  const animationType = animationTypeMap[config.__type as keyof typeof animationTypeMap]
+  if (!animationType) {
+    throw new Error(`Invalid animation config type ${errorReference}: ${String(config.__type)}`)
+  }
+  return animationType
+}
+
+const assertAnimationComposeType = (composeType: unknown, errorReference: string) => {
+  if (typeof composeType !== 'string' || !animationComposeTypes.has(composeType)) {
+    throw new Error(`Invalid animation compose type ${errorReference}: ${String(composeType)}`)
+  }
+  return composeType
+}
+
+const pickDefinedConfigValues = (config: Record<string, unknown>, keys: string[]) =>
+  keys.reduce((acc, key) => {
+    if (hasDefinedConfigValue(config, key)) acc[key] = config[key]
+    return acc
+  }, {})
+
+const getDefinedConfigKeys = (config: Record<string, unknown>, keys: string[]) =>
+  keys.filter((key) => hasDefinedConfigValue(config, key))
+
+const formatWarningMetadata = (metadata: WarningMetadata = {}) =>
+  Object.entries(metadata)
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `${key}: ${String(value)}`)
+    .join(', ')
+
+const formatWarningReference = (metadata?: WarningMetadata) => {
+  const metadataText = formatWarningMetadata(metadata)
+  return metadataText ? ` [${metadataText}]` : ''
+}
+
+const normalizeSpringConfig = (
+  config: Record<string, unknown>,
+  errorReference: string,
+  warningMetadata?: WarningMetadata,
+): Record<string, unknown> => {
+  assertConfigValue(config, 'toValue', errorReference)
+
+  const usedFamilies = springConfigFamilies.filter((keys) =>
+    keys.some((key) => hasDefinedConfigValue(config, key)),
+  )
+  if (usedFamilies.length <= 1) return config
+
+  const configWithoutSpringFamily = Object.entries(config).reduce((acc, [key, value]) => {
+    if (!springConfigFamilyKeys.has(key)) acc[key] = value
+    return acc
+  }, {})
+
+  // Match runtime normalization: physical spring values are most explicit,
+  // otherwise preserve BRICKS' historical tension/friction controls.
+  const resolvedFamily =
+    usedFamilies.find((keys) => keys.includes('stiffness')) ||
+    usedFamilies.find((keys) => keys.includes('tension')) ||
+    usedFamilies[0]
+  const resolvedFamilyKeys = getDefinedConfigKeys(config, resolvedFamily)
+  const droppedFamilyKeys = usedFamilies
+    .filter((keys) => keys !== resolvedFamily)
+    .flatMap((keys) => getDefinedConfigKeys(config, keys))
+
+  console.warn(
+    `[Warning] Resolved animation spring config${formatWarningReference(
+      warningMetadata,
+    )}: using ${resolvedFamilyKeys.join('/')}, dropping ${droppedFamilyKeys.join('/')}`,
+  )
+
+  return {
+    ...configWithoutSpringFamily,
+    ...pickDefinedConfigValues(config, resolvedFamily),
+  }
+}
+
+const compileAnimationConfig = (
+  animationType: CompiledAnimationType,
+  config: unknown,
+  errorReference: string,
+  warningMetadata?: WarningMetadata,
+) => {
+  if (!isRecord(config)) {
+    throw new Error(`Invalid animation config ${errorReference}: config must be an object`)
+  }
+
+  const compiledConfig = compileProperty(omit(config, '__type'), errorReference)
+
+  if (!isRecord(compiledConfig)) {
+    throw new Error(`Invalid animation config ${errorReference}: config must compile to an object`)
+  }
+
+  if (animationType === 'timing') {
+    assertConfigValue(compiledConfig, 'toValue', errorReference)
+  } else if (animationType === 'spring') {
+    return normalizeSpringConfig(compiledConfig, errorReference, warningMetadata)
+  } else if (animationType === 'decay') {
+    assertConfigValue(compiledConfig, 'velocity', errorReference)
+  }
+
+  return compiledConfig
 }
 
 const compileFrame = (frame: Canvas['items'][number]['frame']) => ({
@@ -629,39 +785,63 @@ export const compile = async (app: Application) => {
             `(animation index: ${animationIndex}, subspace: ${subspaceId})`,
           )
 
-          if (animation.__typename === 'Animation') {
+          const animationTypename = animation.__typename
+          if (animationTypename === 'Animation') {
             const animationDef = animation as AnimationDef
+            const animationErrorReference = `(animation: ${animationId}, subspace ${subspaceId})`
+            const animationWarningMetadata = {
+              animationIndex,
+              animationTitle: animationDef.title,
+              animationAlias: animationDef.alias,
+              animationProperty: animationDef.property,
+              subspaceIndex,
+              subspaceTitle: subspace.title,
+            }
+            const animationType = getAnimationType(animationDef.config, animationErrorReference)
             map[animationId] = {
               alias: animationDef.alias,
               title: animationDef.title,
               description: animationDef.description,
               hide_short_ref: animationDef.hideShortRef,
               animationRunType: animationDef.runType,
-              property: animationDef.property,
-              type: animationTypeMap[animationDef.config.__type],
-              config: compileProperty(
-                omit(animationDef.config, '__type'),
-                `(animation: ${animationId}, subspace ${subspaceId})`,
+              property: assertAnimationProperty(animationDef.property, animationErrorReference),
+              type: animationType,
+              config: compileAnimationConfig(
+                animationType,
+                animationDef.config,
+                animationErrorReference,
+                animationWarningMetadata,
               ),
             }
-          } else if (animation.__typename === 'AnimationCompose') {
+          } else if (animationTypename === 'AnimationCompose') {
             const animationDef = animation as AnimationComposeDef
+            const animationErrorReference = `(animation: ${animationId}, subspace ${subspaceId})`
             map[animationId] = {
               alias: animationDef.alias,
               title: animationDef.title,
               description: animationDef.description,
               hide_short_ref: animationDef.hideShortRef,
               animationRunType: animationDef.runType,
-              compose_type: animationDef.composeType,
+              compose_type: assertAnimationComposeType(
+                animationDef.composeType,
+                animationErrorReference,
+              ),
               item_list: animationDef.items.map((item, index) => {
                 const innerAnimation = item()
-                if (!innerAnimation?.id)
-                  throw new Error(
-                    `Invalid animation index: ${index} (animation: ${innerAnimation.id}, subspace ${subspaceId})`,
-                  )
-                return { animation_id: innerAnimation.id }
+                const innerAnimationId = assertEntryId(
+                  innerAnimation?.id,
+                  'ANIMATION',
+                  `(animation item index: ${index}, animation: ${animationId}, subspace ${subspaceId})`,
+                )
+                return { animation_id: innerAnimationId }
               }),
             }
+          } else {
+            throw new Error(
+              `Invalid animation typename (animation: ${animationId}, subspace ${subspaceId}): ${String(
+                animationTypename,
+              )}`,
+            )
           }
           return map
         }, {}),

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.6",
+  "version": "2.25.0-beta.8",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.6",
+    "@fugood/bricks-cli": "^2.25.0-beta.8",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
@@ -25,5 +25,5 @@
   "peerDependencies": {
     "oxfmt": "^0.36.0"
   },
-  "gitHead": "d8a3bbd695e9118cf725b7226866d804bbe56bbe"
+  "gitHead": "9b2439118ca2226b7eeb88f986f9da236c340d83"
 }

package/skills/bricks-ctor/rules/animation.md

@@ -41,12 +41,13 @@ const bounce: AnimationDef = {
     toValue: 1,
     friction: 7,
     tension: 40,
-    speed: 12,
-    bounciness: 8,
   },
 }
 ```
 
+Use one spring parameter family per config: `tension/friction`, `speed/bounciness`, or
+`stiffness/damping/mass`.
+
 ### Decay Animation
 Velocity-based deceleration animation.
 

package/tools/preview-main.mjs

@@ -6,6 +6,12 @@ import { createServer } from 'http'
 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: {
@@ -224,16 +230,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)
     }
   }

package/types/animation.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'

package/types/bricks/Image.ts

@@ -25,6 +25,10 @@ Default property:
   "templateType": "${}",
   "fadeDuration": 0,
   "blurBackgroundRadius": 8,
+  "imageFilterEnabled": false,
+  "imageFilterBlur": 0,
+  "imageFilterBlurMode": "clamp",
+  "imageFilterColorMatrix": [],
   "loadSystemIos": "auto",
   "loadSystemAndroid": "auto"
 }
@@ -50,6 +54,14 @@ Default property:
     enableBlurBackground?: boolean | DataLink
     /* The blur radius of the blur filter added to the image background */
     blurBackgroundRadius?: number | DataLink
+    /* Enable Skia image filters. When disabled, Image uses the normal platform image renderer. */
+    imageFilterEnabled?: boolean | DataLink
+    /* Blur amount for the Skia image filter. */
+    imageFilterBlur?: number | DataLink
+    /* Tile mode for the Skia blur image filter. */
+    imageFilterBlurMode?: 'clamp' | 'decal' | 'repeat' | 'mirror' | DataLink
+    /* Optional 4x5 color matrix for the Skia image filter. Provide 20 numbers. */
+    imageFilterColorMatrix?: Array<number | DataLink> | DataLink
     /* [iOS] The use priority of image loading system (Auto: sdwebimage, fallback to default if failed) */
     loadSystemIos?: 'auto' | 'sdwebimage' | 'default' | DataLink
     /* [Android] The use priority of image loading system (Auto: glide, fallback to fresco if failed) */

package/types/data.ts

@@ -18,7 +18,7 @@ export type Data<T = any> = DataDef & {
   __typename: 'Data'
   id: string
   alias?: string
-  title: string
+  title?: string
   description?: string
   hideShortRef?: boolean
   metadata?: {

package/types/subspace.ts

@@ -7,7 +7,7 @@ import type { DataCalculation } from './data-calc'
 export type Subspace = {
   __typename: 'Subspace'
   id: string
-  title: string
+  title?: string
   description?: string
   hideShortRef?: boolean
   unused?: boolean

package/utils/__tests__/id.test.js

@@ -0,0 +1,58 @@
+import { makeId } from '../id'
+
+const UUID = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
+const UUID_ONLY_RE = new RegExp(`^${UUID}$`)
+
+describe('makeId', () => {
+  describe('type prefixes', () => {
+    const cases = [
+      ['animation', 'ANIMATION_'],
+      ['brick', 'BRICK_'],
+      ['dynamic-brick', 'DYNAMIC_BRICK_'],
+      ['canvas', 'CANVAS_'],
+      ['generator', 'GENERATOR_'],
+      ['data', 'PROPERTY_BANK_DATA_NODE_'],
+      ['switch', 'BRICK_STATE_GROUP_'],
+      ['property_bank_command', 'PROPERTY_BANK_COMMAND_NODE_'],
+      ['property_bank_calc', 'PROPERTY_BANK_COMMAND_MAP_'],
+      ['automation_map', 'AUTOMATION_MAP_'],
+      ['test', 'TEST_'],
+      ['test_case', 'TEST_CASE_'],
+      ['test_var', 'TEST_VAR_'],
+    ]
+
+    test.each(cases)('produces %p prefix', (type, prefix) => {
+      expect(makeId(type)).toMatch(new RegExp(`^${prefix}${UUID}$`))
+    })
+
+    test('returns unique random uuids across calls', () => {
+      expect(makeId('brick')).not.toBe(makeId('brick'))
+    })
+
+    test('unknown type falls through to an unprefixed uuid', () => {
+      expect(makeId('not-a-real-type')).toMatch(UUID_ONLY_RE)
+    })
+  })
+
+  describe('subspace', () => {
+    test('throws because subspace IDs must be fixed', () => {
+      expect(() => makeId('subspace')).toThrow(/subspace is not supported/)
+    })
+  })
+
+  describe('snapshotMode', () => {
+    test('produces sequential, deterministic uuids', () => {
+      const a = makeId('brick', { snapshotMode: true })
+      const b = makeId('brick', { snapshotMode: true })
+      expect(a).toMatch(/^BRICK_00000000-0000-0000-0000-\d{12}$/)
+      expect(b).toMatch(/^BRICK_00000000-0000-0000-0000-\d{12}$/)
+      expect(Number(b.slice(-12))).toBe(Number(a.slice(-12)) + 1)
+    })
+
+    test('snapshotMode false falls back to random uuid', () => {
+      const id = makeId('canvas', { snapshotMode: false })
+      expect(id).toMatch(new RegExp(`^CANVAS_${UUID}$`))
+      expect(id).not.toMatch(/CANVAS_00000000-0000-0000-0000-/)
+    })
+  })
+})

package/utils/data.ts

@@ -86,7 +86,7 @@ type SystemDataInfo = {
   name: SystemDataName
   id: string
   type: 'string' | 'number' | 'bool' | 'array' | 'object' | 'any'
-  title: string
+  title?: string
   description?: string
   schema?: object
   value?: any