@payfit/unity-themes 2.55.22 → 2.56.0

package/src/scripts/transforms/tailwind-text-token.test.ts

@@ -1,328 +0,0 @@
-import type { Token } from 'style-dictionary'
-import type { Config, PlatformConfig } from 'style-dictionary/types'
-
-import { describe, expect, it } from 'vitest'
-
-import { filter, transform } from './tailwind-text-token.js'
-
-describe('tailwind text token transform', () => {
-  const createMockToken = (path: string[]): Token =>
-    ({
-      name: 'test-token',
-      value: '400 1rem/1.5 Inter',
-      type: 'typography',
-      path,
-      original: {},
-      filePath: '',
-      isSource: false,
-    }) as Token
-
-  const createMockConfig = (): Config => ({
-    platforms: {},
-    source: [],
-    include: [],
-  })
-
-  const createMockPlatformConfig = (): PlatformConfig => ({
-    transforms: [],
-    buildPath: '',
-    files: [],
-  })
-
-  describe('filter', () => {
-    it('should return true for tokens with text as first path element', () => {
-      const token = createMockToken(['text', 'heading', 'h1'])
-      const config = createMockConfig()
-
-      const result = filter(token, config)
-
-      expect(result).toBe(true)
-    })
-
-    it('should return false for tokens without text as first path element', () => {
-      const testCases = [
-        ['color', 'primary', 'default'],
-        ['spacing', '1', 'base'],
-        ['typography', 'heading', 'h1'],
-        ['border', 'width', 'thin'],
-        ['shadow', 'small'],
-        ['breakpoint', 'mobile'],
-      ]
-
-      testCases.forEach(path => {
-        const token = createMockToken(path)
-        const config = createMockConfig()
-
-        const result = filter(token, config)
-
-        expect(result).toBe(false)
-      })
-    })
-
-    it('should return false for empty path', () => {
-      const token = createMockToken([])
-      const config = createMockConfig()
-
-      const result = filter(token, config)
-
-      expect(result).toBe(false)
-    })
-
-    it('should return false for single element path that is not text', () => {
-      const token = createMockToken(['color'])
-      const config = createMockConfig()
-
-      const result = filter(token, config)
-
-      expect(result).toBe(false)
-    })
-
-    it('should handle case sensitivity', () => {
-      const testCases = [
-        { path: ['Text', 'heading'], expected: false },
-        { path: ['TEXT', 'heading'], expected: false },
-        { path: ['text', 'heading'], expected: true },
-      ]
-
-      testCases.forEach(({ path, expected }) => {
-        const token = createMockToken(path)
-        const config = createMockConfig()
-
-        const result = filter(token, config)
-
-        expect(result).toBe(expected)
-      })
-    })
-  })
-
-  describe('transform', () => {
-    it('should return text-{size} when second path element does not contain --', () => {
-      const token = createMockToken(['text', 'heading'])
-      const config = createMockPlatformConfig()
-
-      const result = transform(token, config)
-
-      expect(result).toBe('text-heading')
-    })
-
-    it('should return text-{size}--{suffix} when second path element contains --', () => {
-      const token = createMockToken(['text', 'heading--large'])
-      const config = createMockPlatformConfig()
-
-      const result = transform(token, config)
-
-      expect(result).toBe('text-heading--large')
-    })
-
-    it('should handle path with only text element', () => {
-      const token = createMockToken(['text'])
-      const config = createMockPlatformConfig()
-
-      const result = transform(token, config)
-
-      expect(result).toBe('text-undefined')
-    })
-
-    it('should handle path with text and empty second element', () => {
-      const token = createMockToken(['text', ''])
-      const config = createMockPlatformConfig()
-
-      const result = transform(token, config)
-
-      expect(result).toBe('text-')
-    })
-
-    it('should handle complex text paths without --', () => {
-      const testCases = [
-        { path: ['text', 'heading'], expected: 'text-heading' },
-        { path: ['text', 'body'], expected: 'text-body' },
-        { path: ['text', 'caption'], expected: 'text-caption' },
-        { path: ['text', 'label'], expected: 'text-label' },
-      ]
-
-      testCases.forEach(({ path, expected }) => {
-        const token = createMockToken(path)
-        const config = createMockPlatformConfig()
-
-        const result = transform(token, config)
-
-        expect(result).toBe(expected)
-      })
-    })
-
-    it('should handle complex text paths with --', () => {
-      const testCases = [
-        { path: ['text', 'heading--large'], expected: 'text-heading--large' },
-        { path: ['text', 'body--small'], expected: 'text-body--small' },
-        { path: ['text', 'caption--medium'], expected: 'text-caption--medium' },
-        { path: ['text', 'label--bold'], expected: 'text-label--bold' },
-      ]
-
-      testCases.forEach(({ path, expected }) => {
-        const token = createMockToken(path)
-        const config = createMockPlatformConfig()
-
-        const result = transform(token, config)
-
-        expect(result).toBe(expected)
-      })
-    })
-
-    it('should handle text paths with numbers', () => {
-      const testCases = [
-        { path: ['text', 'heading-1'], expected: 'text-heading-1' },
-        { path: ['text', 'body-2'], expected: 'text-body-2' },
-        {
-          path: ['text', 'caption-3--large'],
-          expected: 'text-caption-3--large',
-        },
-      ]
-
-      testCases.forEach(({ path, expected }) => {
-        const token = createMockToken(path)
-        const config = createMockPlatformConfig()
-
-        const result = transform(token, config)
-
-        expect(result).toBe(expected)
-      })
-    })
-
-    it('should handle text paths with special characters', () => {
-      const testCases = [
-        {
-          path: ['text', 'heading-with-dash'],
-          expected: 'text-heading-with-dash',
-        },
-        {
-          path: ['text', 'body_with_underscore'],
-          expected: 'text-body_with_underscore',
-        },
-        {
-          path: ['text', 'caption.with.dot'],
-          expected: 'text-caption.with.dot',
-        },
-        {
-          path: ['text', 'label--with-dash'],
-          expected: 'text-label--with-dash',
-        },
-      ]
-
-      testCases.forEach(({ path, expected }) => {
-        const token = createMockToken(path)
-        const config = createMockPlatformConfig()
-
-        const result = transform(token, config)
-
-        expect(result).toBe(expected)
-      })
-    })
-
-    it('should handle edge cases with -- at different positions', () => {
-      const testCases = [
-        { path: ['text', '--heading'], expected: 'text---heading' },
-        { path: ['text', 'heading--'], expected: 'text-heading--' },
-        { path: ['text', '--'], expected: 'text---' },
-        { path: ['text', '---'], expected: 'text----' },
-      ]
-
-      testCases.forEach(({ path, expected }) => {
-        const token = createMockToken(path)
-        const config = createMockPlatformConfig()
-
-        const result = transform(token, config)
-
-        expect(result).toBe(expected)
-      })
-    })
-
-    it('should handle path with whitespace', () => {
-      const testCases = [
-        { path: ['text', ' heading'], expected: 'text- heading' },
-        { path: ['text', 'heading '], expected: 'text-heading ' },
-        { path: ['text', ' heading '], expected: 'text- heading ' },
-        { path: ['text', 'heading-- large'], expected: 'text-heading-- large' },
-      ]
-
-      testCases.forEach(({ path, expected }) => {
-        const token = createMockToken(path)
-        const config = createMockPlatformConfig()
-
-        const result = transform(token, config)
-
-        expect(result).toBe(expected)
-      })
-    })
-
-    it('should handle path with only -- in second element', () => {
-      const token = createMockToken(['text', '--'])
-      const config = createMockPlatformConfig()
-
-      const result = transform(token, config)
-
-      expect(result).toBe('text---')
-    })
-
-    it('should handle path with empty string after --', () => {
-      const token = createMockToken(['text', 'heading--'])
-      const config = createMockPlatformConfig()
-
-      const result = transform(token, config)
-
-      expect(result).toBe('text-heading--')
-    })
-
-    it('should handle path with empty string before --', () => {
-      const token = createMockToken(['text', '--large'])
-      const config = createMockPlatformConfig()
-
-      const result = transform(token, config)
-
-      expect(result).toBe('text---large')
-    })
-
-    it('should handle path with mixed content and --', () => {
-      const testCases = [
-        {
-          path: ['text', 'heading-large--bold'],
-          expected: 'text-heading-large--bold',
-        },
-        {
-          path: ['text', 'body-small--italic'],
-          expected: 'text-body-small--italic',
-        },
-        {
-          path: ['text', 'caption-medium--underline'],
-          expected: 'text-caption-medium--underline',
-        },
-      ]
-
-      testCases.forEach(({ path, expected }) => {
-        const token = createMockToken(path)
-        const config = createMockPlatformConfig()
-
-        const result = transform(token, config)
-
-        expect(result).toBe(expected)
-      })
-    })
-
-    it('should prepend prefix when config.prefix is set', () => {
-      const token = createMockToken(['text', 'heading'])
-      const config = { ...createMockPlatformConfig(), prefix: 'uy' }
-
-      const result = transform(token, config)
-
-      expect(result).toBe('uy-text-heading')
-    })
-
-    it('should prepend prefix with -- variant when config.prefix is set', () => {
-      const token = createMockToken(['text', 'heading--large'])
-      const config = { ...createMockPlatformConfig(), prefix: 'uy' }
-
-      const result = transform(token, config)
-
-      expect(result).toBe('uy-text-heading--large')
-    })
-  })
-})

package/src/scripts/transforms/tailwind-text-token.ts

@@ -1,30 +0,0 @@
-import type { Token } from 'style-dictionary'
-import type {
-  Config,
-  NameTransform,
-  PlatformConfig,
-} from 'style-dictionary/types'
-
-import { prefixTransform } from '../utils/prefix-transform'
-
-type Transformer = NameTransform['transform']
-
-export function filter(token: Token, options: Config): boolean {
-  return token.path[0] === 'text'
-}
-
-const tailwindTextTokenNameTransform: Transformer = (
-  token: Token,
-  config: PlatformConfig,
-) => {
-  const path = token.path as string[]
-
-  if (path[1]?.includes('--')) {
-    const [size, suffix] = path[1].split('--') as [string, string]
-    return `text-${size}--${suffix}`
-  }
-
-  return `text-${path[1]}`
-}
-
-export const transform = prefixTransform(tailwindTextTokenNameTransform)

package/src/scripts/transforms/tailwind-typography-token.test.ts

@@ -1,55 +0,0 @@
-import type { TransformedToken } from 'style-dictionary/types'
-
-import { describe, expect, it } from 'vitest'
-
-import { filter, transform } from './tailwind-typography-token.js'
-
-describe('tailwind typography token transform', () => {
-  const createMockToken = (
-    path: string[],
-    type = 'typography',
-  ): TransformedToken =>
-    ({
-      name: 'test-token',
-      value: '400 1rem/1.5 Inter',
-      $type: type,
-      path,
-      original: {},
-      filePath: '',
-      isSource: false,
-    }) as TransformedToken
-
-  describe('filter', () => {
-    it('should return true for tokens with $type typography', () => {
-      const token = createMockToken(['typography', 'h1', 'default'])
-      const result = filter(token)
-      expect(result).toBe(true)
-    })
-
-    it('should return false for tokens without $type typography', () => {
-      const token = createMockToken(['color', 'primary', 'default'], 'color')
-      const result = filter(token)
-      expect(result).toBe(false)
-    })
-  })
-
-  describe('transform', () => {
-    it('should reorder the path elements correctly', () => {
-      const token = createMockToken(['typography', 'h1', 'sm'])
-      const result = transform(token, {}, {})
-      expect(result).toBe('typography-sm-h1')
-    })
-
-    it('should handle "default" breakpoint correctly', () => {
-      const token = createMockToken(['typography', 'h1', 'default'])
-      const result = transform(token, {}, {})
-      expect(result).toBe('typography-default-h1')
-    })
-
-    it('should prepend prefix when config.prefix is set', () => {
-      const token = createMockToken(['typography', 'h1', 'sm'])
-      const result = transform(token, { prefix: 'uy' }, {})
-      expect(result).toBe('uy-typography-sm-h1')
-    })
-  })
-})

package/src/scripts/transforms/tailwind-typography-token.ts

@@ -1,20 +0,0 @@
-import type { Token } from 'style-dictionary'
-import type { NameTransform } from 'style-dictionary/types'
-
-import { prefixTransform } from '../utils/prefix-transform'
-
-type Transformer = NameTransform['transform']
-
-export function filter(token: Token): boolean {
-  return token.$type === 'typography'
-}
-
-const tailwindTypographyTransform: Transformer = (token, config) => {
-  const [_category, type, item] = token.path
-  // Reorders the token path from [typography, h1, sm]
-  // to the string "typography-sm-h1"
-  const newPath = ['typography', item, type]
-  return newPath.join('-')
-}
-
-export const transform = prefixTransform(tailwindTypographyTransform)

package/src/scripts/types.ts

@@ -1,30 +0,0 @@
-import type {
-  Config,
-  LocalOptions,
-  TransformedToken,
-} from 'style-dictionary/types'
-
-export type TokenWithCTIAttrs = TransformedToken & {
-  attributes: {
-    category: string
-    type: string
-    item: string
-  }
-}
-
-export type BreakpointToken = TransformedToken & {
-  $value: string
-  $type: 'dimension'
-}
-
-export type TypographyGroup = {
-  default?: TokenWithCTIAttrs
-  responsive: Map<string, TokenWithCTIAttrs>
-}
-
-export type ProcessorOptions = Config & LocalOptions
-
-export type Prefixes = {
-  classPrefix: string
-  variablePrefix: string
-}

package/src/scripts/utils/prefix-transform.test.ts

@@ -1,137 +0,0 @@
-import type {
-  Config,
-  PlatformConfig,
-  TransformedToken,
-} from 'style-dictionary/types'
-
-import { describe, expect, it, vi } from 'vitest'
-
-import { prefixTransform } from './prefix-transform.js'
-
-describe('prefixTransform', () => {
-  const createMockToken = (): TransformedToken =>
-    ({
-      name: 'test-token',
-      value: '#000000',
-      type: 'color',
-      path: ['color', 'primary'],
-      original: {},
-      filePath: '',
-      isSource: false,
-    }) as TransformedToken
-
-  const createMockConfig = (prefix?: string): PlatformConfig =>
-    ({
-      platforms: {},
-      source: [],
-      include: [],
-      prefix,
-    }) as unknown as PlatformConfig
-
-  const createMockOptions = (): Config =>
-    ({
-      platforms: {},
-      source: [],
-      include: [],
-    }) as Config
-
-  describe('without prefix', () => {
-    it('should return the original transformer value when no prefix is set', () => {
-      const transformer = vi.fn(() => 'color-primary')
-      const wrapped = prefixTransform(transformer)
-
-      const result = wrapped(
-        createMockToken(),
-        createMockConfig(),
-        createMockOptions(),
-      )
-
-      expect(result).toBe('color-primary')
-    })
-
-    it('should return the original transformer value when prefix is empty string', () => {
-      const transformer = vi.fn(() => 'color-primary')
-      const wrapped = prefixTransform(transformer)
-
-      const result = wrapped(
-        createMockToken(),
-        createMockConfig(''),
-        createMockOptions(),
-      )
-
-      expect(result).toBe('color-primary')
-    })
-  })
-
-  describe('with prefix', () => {
-    it('should prepend the prefix to the transformer value', () => {
-      const transformer = vi.fn(() => 'color-primary')
-      const wrapped = prefixTransform(transformer)
-
-      const result = wrapped(
-        createMockToken(),
-        createMockConfig('uy'),
-        createMockOptions(),
-      )
-
-      expect(result).toBe('uy-color-primary')
-    })
-
-    it('should work with different prefix values', () => {
-      const transformer = vi.fn(() => 'spacing-md')
-      const wrapped = prefixTransform(transformer)
-
-      const result = wrapped(
-        createMockToken(),
-        createMockConfig('my-prefix'),
-        createMockOptions(),
-      )
-
-      expect(result).toBe('my-prefix-spacing-md')
-    })
-  })
-
-  describe('async transformer', () => {
-    it('should handle a transformer that returns a Promise', async () => {
-      const transformer = vi.fn(() => Promise.resolve('color-primary'))
-      const wrapped = prefixTransform(transformer)
-
-      const result = wrapped(
-        createMockToken(),
-        createMockConfig('uy'),
-        createMockOptions(),
-      )
-
-      expect(result).toBeInstanceOf(Promise)
-      await expect(result).resolves.toBe('uy-color-primary')
-    })
-
-    it('should handle a Promise result without prefix', async () => {
-      const transformer = vi.fn(() => Promise.resolve('color-primary'))
-      const wrapped = prefixTransform(transformer)
-
-      const result = wrapped(
-        createMockToken(),
-        createMockConfig(),
-        createMockOptions(),
-      )
-
-      await expect(result).resolves.toBe('color-primary')
-    })
-  })
-
-  describe('argument passthrough', () => {
-    it('should forward all arguments to the wrapped transformer', () => {
-      const transformer = vi.fn(() => 'result')
-      const wrapped = prefixTransform(transformer)
-
-      const token = createMockToken()
-      const config = createMockConfig('uy')
-      const options = createMockOptions()
-
-      void wrapped(token, config, options)
-
-      expect(transformer).toHaveBeenCalledWith(token, config, options)
-    })
-  })
-})

package/src/scripts/utils/prefix-transform.ts

@@ -1,16 +0,0 @@
-import type { NameTransform } from 'style-dictionary/types'
-
-type Transformer = NameTransform['transform']
-
-export const prefixTransform: (transformer: Transformer) => Transformer =
-  transformer =>
-  (...args) => {
-    const [, config] = args
-    const prefix = config.prefix ? `${config.prefix}-` : ''
-    const value = transformer(...args)
-
-    if (value instanceof Promise) {
-      return value.then(val => `${prefix}${val}`)
-    }
-    return `${prefix}${value}`
-  }