AI-native design editor. Open-source Figma alternative.
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
})
})