Skip to content

AI-native design editor. Open-source Figma alternative.

4.5 KB
Raw Blame
import { expect, test } from 'bun:test'

import { linearVariableExpression } from '#fig/node-change/variable/expression'

import { nodeChangeToProps } from '@open-pencil/fig/node-change'
import type { VariableDataEntry } from '@open-pencil/kiwi/fig/codec'

const alias: VariableDataEntry = {
  dataType: 'ALIAS',
  value: { alias: { guid: { sessionID: 1, localID: 2 } } }
}
const literal = (floatValue: number): VariableDataEntry => ({
  dataType: 'FLOAT',
  value: { floatValue }
})
const multiply = (...expressionArguments: VariableDataEntry[]): VariableDataEntry => ({
  dataType: 'EXPRESSION',
  value: { expressionValue: { expressionFunction: 'MULTIPLY', expressionArguments } }
})

test('linear products retain their symbolic alias and exact coefficient', () => {
  expect(linearVariableExpression(multiply(literal(2), multiply(alias, literal(0.25))))).toEqual({
    reference: alias.value?.alias,
    multiplier: 0.5
  })
  const props = nodeChangeToProps(
    {
      type: 'FRAME',
      parameterConsumptionMap: {
        entries: [
          {
            variableField: 'OPACITY',
            variableData: multiply(literal(0.5), alias)
          }
        ]
      }
    },
    []
  )
  expect(props.boundVariables).toEqual({ opacity: '1:2' })
  expect(props.variableBindingScales).toEqual({ opacity: 0.005 })
})

test('nonlinear, unsupported, overflowing, and unbounded expressions fail rather than lose bindings', () => {
  expect(() => linearVariableExpression(multiply(alias, alias))).toThrow('one alias')
  expect(() => linearVariableExpression({ dataType: 'EXPRESSION' })).toThrow('Missing')
  expect(() =>
    nodeChangeToProps(
      {
        type: 'FRAME',
        parameterConsumptionMap: {
          entries: [
            {
              variableField: 'WIDTH',
              variableData: multiply(literal(2), literal(3))
            }
          ]
        }
      },
      []
    )
  ).toThrow('one alias')
  expect(() =>
    linearVariableExpression({ value: { expressionValue: { expressionFunction: 'ADD' } } })
  ).toThrow('Unsupported')
  expect(() =>
    linearVariableExpression(multiply(literal(Number.MAX_VALUE), literal(2), alias))
  ).toThrow('non-finite')
  let deep = alias
  for (let index = 0; index < 66; index++) deep = multiply(literal(1), deep)
  expect(() => linearVariableExpression(deep)).toThrow('maximum depth')
})

test('STRINGIFY of one alias is that alias, as Figma binds a number to text content', () => {
  const stringify = (...expressionArguments: VariableDataEntry[]): VariableDataEntry => ({
    dataType: 'EXPRESSION',
    value: { expressionValue: { expressionFunction: 'STRINGIFY', expressionArguments } }
  })
  expect(linearVariableExpression(stringify(alias))).toEqual({
    reference: alias.value?.alias,
    multiplier: 1
  })
  expect(() => linearVariableExpression(stringify(multiply(literal(2), alias)))).toThrow(
    'STRINGIFY'
  )
  expect(() => linearVariableExpression(stringify(alias, alias))).toThrow('STRINGIFY')
  // Reads as a multiplier of 1, but saving it as a plain binding would drop the product.
  expect(() =>
    linearVariableExpression(stringify(multiply(literal(2), literal(0.5), alias)))
  ).toThrow('STRINGIFY')
})

test('IS_TRUTHY of one alias is that alias, as Figma binds a boolean or text to visibility', () => {
  const truthy = (...expressionArguments: VariableDataEntry[]): VariableDataEntry => ({
    dataType: 'EXPRESSION',
    resolvedDataType: 'BOOLEAN',
    value: { expressionValue: { expressionFunction: 'IS_TRUTHY', expressionArguments } }
  })
  const booleanAlias = { ...alias, resolvedDataType: 'BOOLEAN' }
  expect(linearVariableExpression(truthy(booleanAlias))).toEqual({
    reference: alias.value?.alias,
    multiplier: 1
  })
  const props = nodeChangeToProps(
    {
      type: 'FRAME',
      parameterConsumptionMap: {
        entries: [{ variableField: 'VISIBLE', variableData: truthy(booleanAlias) }]
      }
    },
    []
  )
  expect(props.boundVariables).toEqual({ visible: '1:2' })
  expect(props.variableBindingScales).toEqual({})
  expect(() => linearVariableExpression(truthy())).toThrow('one alias')
  expect(() => linearVariableExpression(truthy(booleanAlias, booleanAlias))).toThrow('one alias')
  expect(() => linearVariableExpression(truthy(multiply(literal(2), alias)))).toThrow('one alias')
  // The binding resolves through Figma's truthiness, so a text alias reads the same way.
  expect(linearVariableExpression(truthy({ ...alias, resolvedDataType: 'STRING' }))).toEqual({
    reference: alias.value?.alias,
    multiplier: 1
  })
})