@primer/primitives 7.17.0-rc.61b28bca → 7.17.0-rc.8ff6ed39

package/src/schemas/collectionSchema.test.ts

@@ -1,58 +0,0 @@
-import {collection, mode} from './collections'
-
-describe('Schema: collection', () => {
-  const collections = collection([
-    'base/color/light',
-    'base/color/light-high-contrast',
-    'base/color/dark',
-    'base/color/dark-dimmed',
-    'base/color/dark-high-contrast',
-    'mode',
-    'pattern/mode',
-  ])
-  it('passes on valid values', () => {
-    expect(collections.safeParse('mode').success).toStrictEqual(true)
-    expect(collections.safeParse('base/color/light').success).toStrictEqual(true)
-  })
-
-  it('fails on invalid values', () => {
-    expect(collections.safeParse('wrongCollection').success).toStrictEqual(false)
-    expect(collections.safeParse('').success).toStrictEqual(false)
-  })
-
-  it('fails on non-string values', () => {
-    expect(collections.safeParse(undefined).success).toStrictEqual(false)
-    expect(collections.safeParse(null).success).toStrictEqual(false)
-    expect(collections.safeParse(1).success).toStrictEqual(false)
-  })
-})
-
-describe('Schema: mode', () => {
-  const modes = mode([
-    'light',
-    'dark',
-    'dark dimmed',
-    'light high contrast',
-    'dark high contrast',
-    'light colorblind',
-    'dark colorblind',
-    'light tritanopia',
-    'dark tritanopia',
-  ])
-
-  it('passes on valid values', () => {
-    expect(modes.safeParse('light').success).toStrictEqual(true)
-    expect(modes.safeParse('dark').success).toStrictEqual(true)
-  })
-
-  it('fails on invalid values', () => {
-    expect(modes.safeParse('wrongMode').success).toStrictEqual(false)
-    expect(modes.safeParse('').success).toStrictEqual(false)
-  })
-
-  it('fails on non-string values', () => {
-    expect(modes.safeParse(undefined).success).toStrictEqual(false)
-    expect(modes.safeParse(null).success).toStrictEqual(false)
-    expect(modes.safeParse(1).success).toStrictEqual(false)
-  })
-})

package/src/schemas/colorHexValueSchema.test.ts

@@ -1,26 +0,0 @@
-import {colorHexValue} from './colorHexValue'
-
-describe('Schema: colorHexValue', () => {
-  it('passes on valid colorHexValue values', () => {
-    expect(colorHexValue.safeParse('#333').success).toStrictEqual(true)
-    // expect(colorHexValue.safeParse('#3456').success).toStrictEqual(true)
-    expect(colorHexValue.safeParse('#33ff55').success).toStrictEqual(true)
-    expect(colorHexValue.safeParse('#33aa5566').success).toStrictEqual(true)
-  })
-
-  it('fails on invalid colorHexValue values', () => {
-    expect(colorHexValue.safeParse('#3456').success).toStrictEqual(false)
-    expect(colorHexValue.safeParse(0).success).toStrictEqual(false)
-    expect(colorHexValue.safeParse('345').success).toStrictEqual(false)
-    expect(colorHexValue.safeParse('334455').success).toStrictEqual(false)
-    expect(colorHexValue.safeParse('blue').success).toStrictEqual(false)
-    expect(colorHexValue.safeParse('rgb(255,125,0)').success).toStrictEqual(false)
-    expect(colorHexValue.safeParse('').success).toStrictEqual(false)
-  })
-
-  it('fails on non-string values', () => {
-    expect(colorHexValue.safeParse(undefined).success).toStrictEqual(false)
-    expect(colorHexValue.safeParse(null).success).toStrictEqual(false)
-    expect(colorHexValue.safeParse(1).success).toStrictEqual(false)
-  })
-})

package/src/schemas/colorTokenSchema.test.ts

@@ -1,27 +0,0 @@
-import {colorToken} from './colorToken'
-
-describe('Schema: colorToken', () => {
-  const validToken = {
-    $value: '#00ff88',
-    $type: 'color',
-    $description: 'a color token',
-  }
-
-  it('passes on valid values', () => {
-    expect(colorToken.safeParse(validToken).success).toStrictEqual(true)
-    expect(colorToken.safeParse({...validToken, $value: '#000'}).success).toStrictEqual(true)
-    expect(colorToken.safeParse({...validToken, $value: '#11223366'}).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid type', () => {
-    expect(colorToken.safeParse({...validToken, $type: 'stroke'}).success).toStrictEqual(false)
-  })
-
-  it('fails on invalid value', () => {
-    expect(colorToken.safeParse({...validToken, $value: 'wrong'}).success).toStrictEqual(false)
-    expect(colorToken.safeParse({...validToken, $value: undefined}).success).toStrictEqual(false)
-    expect(colorToken.safeParse({...validToken, $value: ''}).success).toStrictEqual(false)
-    expect(colorToken.safeParse({...validToken, $value: false}).success).toStrictEqual(false)
-    expect(colorToken.safeParse({...validToken, $value: 1}).success).toStrictEqual(false)
-  })
-})

package/src/schemas/dimensionTokenSchema.test.ts

@@ -1,28 +0,0 @@
-import {dimensionToken} from './dimensionToken'
-
-describe('Schema: dimensionToken', () => {
-  const validToken = {
-    $value: '1px',
-    $type: 'dimension',
-    $description: 'a dimension token',
-  }
-
-  it('passes on valid values', () => {
-    expect(dimensionToken.safeParse(validToken).success).toStrictEqual(true)
-    expect(dimensionToken.safeParse({...validToken, $value: '1em'}).success).toStrictEqual(true)
-    expect(dimensionToken.safeParse({...validToken, $value: '1rem'}).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid type', () => {
-    expect(dimensionToken.safeParse({...validToken, $type: 'stroke'}).success).toStrictEqual(false)
-  })
-
-  it('fails on invalid value', () => {
-    expect(dimensionToken.safeParse({...validToken, $value: 'wrong'}).success).toStrictEqual(false)
-    expect(dimensionToken.safeParse({...validToken, $value: '1%'}).success).toStrictEqual(false)
-    expect(dimensionToken.safeParse({...validToken, $value: undefined}).success).toStrictEqual(false)
-    expect(dimensionToken.safeParse({...validToken, $value: ''}).success).toStrictEqual(false)
-    expect(dimensionToken.safeParse({...validToken, $value: false}).success).toStrictEqual(false)
-    expect(dimensionToken.safeParse({...validToken, $value: 1}).success).toStrictEqual(false)
-  })
-})

package/src/schemas/dimensionValueSchema.test.ts

@@ -1,21 +0,0 @@
-import {dimensionValue} from './dimensionValue'
-
-describe('Schema: dimensionValue', () => {
-  it('passes on valid values', () => {
-    expect(dimensionValue.safeParse('1px').success).toStrictEqual(true)
-    expect(dimensionValue.safeParse('-1px').success).toStrictEqual(true)
-    expect(dimensionValue.safeParse('1em').success).toStrictEqual(true)
-    expect(dimensionValue.safeParse('1rem').success).toStrictEqual(true)
-    expect(dimensionValue.safeParse('0').success).toStrictEqual(true)
-    expect(dimensionValue.safeParse(0).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid value', () => {
-    expect(dimensionValue.safeParse('1%').success).toStrictEqual(false)
-    expect(dimensionValue.safeParse(1).success).toStrictEqual(false)
-    expect(dimensionValue.safeParse('small').success).toStrictEqual(false)
-    expect(dimensionValue.safeParse('').success).toStrictEqual(false)
-    expect(dimensionValue.safeParse(false).success).toStrictEqual(false)
-    expect(dimensionValue.safeParse(undefined).success).toStrictEqual(false)
-  })
-})

package/src/schemas/durationTokenSchema.test.ts

@@ -1,58 +0,0 @@
-import {durationToken} from './durationToken'
-
-describe('Schema: durationToken', () => {
-  const validToken = {
-    $value: '1000ms',
-    $type: 'duration',
-    $description: '1000 milliseconds',
-  }
-
-  it('parses valid duration tokens', () => {
-    expect(durationToken.safeParse(validToken).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid properties', () => {
-    // additional element
-    expect(
-      durationToken.safeParse({
-        ...validToken,
-        duration: '1000s',
-      }).success,
-    ).toStrictEqual(false)
-    // missing value
-    expect(
-      durationToken.safeParse({
-        $type: 'duration',
-      }).success,
-    ).toStrictEqual(false)
-    // missing type
-    expect(
-      durationToken.safeParse({
-        $value: '1000ms',
-      }).success,
-    ).toStrictEqual(false)
-  })
-
-  it('fails on wrong type', () => {
-    // invalid string
-    expect(
-      durationToken.safeParse({
-        ...validToken,
-        $type: 'motion',
-      }).success,
-    ).toStrictEqual(false)
-    // undefined
-    expect(
-      durationToken.safeParse({
-        ...validToken,
-        $type: undefined,
-      }).success,
-    ).toStrictEqual(false)
-    // no type
-    expect(
-      durationToken.safeParse({
-        $value: '1000ms',
-      }).success,
-    ).toStrictEqual(false)
-  })
-})

package/src/schemas/durationValueSchema.test.ts

@@ -1,25 +0,0 @@
-import {durationValue} from './durationValue'
-
-describe('Schema: durationValue', () => {
-  it('passes on valid duration values', () => {
-    expect(durationValue.safeParse('0ms').success).toStrictEqual(true)
-    expect(durationValue.safeParse('100ms').success).toStrictEqual(true)
-    expect(durationValue.safeParse('20000ms').success).toStrictEqual(true)
-  })
-
-  it('fails on invalid duration values', () => {
-    expect(durationValue.safeParse(-1).success).toStrictEqual(false)
-    expect(durationValue.safeParse(0).success).toStrictEqual(false)
-    expect(durationValue.safeParse(1.1).success).toStrictEqual(false)
-    expect(durationValue.safeParse('0').success).toStrictEqual(false)
-    expect(durationValue.safeParse('10').success).toStrictEqual(false)
-    expect(durationValue.safeParse('10s').success).toStrictEqual(false)
-    expect(durationValue.safeParse('').success).toStrictEqual(false)
-  })
-
-  it('fails on non-string values', () => {
-    expect(durationValue.safeParse(undefined).success).toStrictEqual(false)
-    expect(durationValue.safeParse(null).success).toStrictEqual(false)
-    expect(durationValue.safeParse(1).success).toStrictEqual(false)
-  })
-})

package/src/schemas/fontFamilyTokenSchema.test.ts

@@ -1,82 +0,0 @@
-import {fontFamilyToken} from './fontFamilyToken'
-
-describe('Schema: fontFamilyToken', () => {
-  const validToken = {
-    $value: 'Helvetica',
-    $type: 'fontFamily',
-    $description: 'a fontFamily token',
-  }
-
-  it('parses valid number tokens', () => {
-    expect(fontFamilyToken.safeParse(validToken).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid properties', () => {
-    // additional element
-    expect(
-      fontFamilyToken.safeParse({
-        ...validToken,
-        additional: 1000,
-      }).success,
-    ).toStrictEqual(false)
-    // missing value
-    expect(
-      fontFamilyToken.safeParse({
-        $type: 'fontWeight',
-      }).success,
-    ).toStrictEqual(false)
-    // missing type
-    expect(
-      fontFamilyToken.safeParse({
-        $value: 'Helvetica',
-      }).success,
-    ).toStrictEqual(false)
-  })
-
-  it('fails on wrong type', () => {
-    // invalid string
-    expect(
-      fontFamilyToken.safeParse({
-        ...validToken,
-        $type: 'motion',
-      }).success,
-    ).toStrictEqual(false)
-    // undefined
-    expect(
-      fontFamilyToken.safeParse({
-        ...validToken,
-        $type: undefined,
-      }).success,
-    ).toStrictEqual(false)
-    // no type
-    expect(
-      fontFamilyToken.safeParse({
-        $value: 'Helvetica',
-      }).success,
-    ).toStrictEqual(false)
-  })
-
-  it('fails on wrong value', () => {
-    // invalid value
-    expect(
-      fontFamilyToken.safeParse({
-        ...validToken,
-        $value: 100,
-      }).success,
-    ).toStrictEqual(false)
-    // undefined
-    expect(
-      fontFamilyToken.safeParse({
-        ...validToken,
-        $value: undefined,
-      }).success,
-    ).toStrictEqual(false)
-    // boolean
-    expect(
-      fontFamilyToken.safeParse({
-        ...validToken,
-        $value: false,
-      }).success,
-    ).toStrictEqual(false)
-  })
-})

package/src/schemas/fontWeightTokenSchema.test.ts

@@ -1,88 +0,0 @@
-import {fontWeightToken} from './fontWeightToken'
-
-describe('Schema: fontWeightToken', () => {
-  const validToken = {
-    $value: 100,
-    $type: 'fontWeight',
-    $description: 'a fontWeight token',
-  }
-
-  it('parses valid number tokens', () => {
-    expect(fontWeightToken.safeParse(validToken).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid properties', () => {
-    // additional element
-    expect(
-      fontWeightToken.safeParse({
-        ...validToken,
-        additional: 1000,
-      }).success,
-    ).toStrictEqual(false)
-    // missing value
-    expect(
-      fontWeightToken.safeParse({
-        $type: 'fontWeight',
-      }).success,
-    ).toStrictEqual(false)
-    // missing type
-    expect(
-      fontWeightToken.safeParse({
-        $value: 100,
-      }).success,
-    ).toStrictEqual(false)
-  })
-
-  it('fails on wrong type', () => {
-    // invalid string
-    expect(
-      fontWeightToken.safeParse({
-        ...validToken,
-        $type: 'motion',
-      }).success,
-    ).toStrictEqual(false)
-    // undefined
-    expect(
-      fontWeightToken.safeParse({
-        ...validToken,
-        $type: undefined,
-      }).success,
-    ).toStrictEqual(false)
-    // no type
-    expect(
-      fontWeightToken.safeParse({
-        $value: 100,
-      }).success,
-    ).toStrictEqual(false)
-  })
-
-  it('fails on wrong value', () => {
-    // invalid string
-    expect(
-      fontWeightToken.safeParse({
-        ...validToken,
-        $value: 'string',
-      }).success,
-    ).toStrictEqual(false)
-    // undefined
-    expect(
-      fontWeightToken.safeParse({
-        ...validToken,
-        $value: undefined,
-      }).success,
-    ).toStrictEqual(false)
-    // boolean
-    expect(
-      fontWeightToken.safeParse({
-        ...validToken,
-        $value: false,
-      }).success,
-    ).toStrictEqual(false)
-    // wrong value
-    expect(
-      fontWeightToken.safeParse({
-        $value: 1500,
-      }).success,
-    ).toStrictEqual(false)
-  })
-})

package/src/schemas/fontWeightValue.test.ts

@@ -1,17 +0,0 @@
-import {fontWeightValue} from './fontWeightValue'
-
-describe('Schema: fontWeightValue', () => {
-  const allowed = [100, 200, 300, 400, 500, 600, 700, 800, 900, 950]
-
-  it('parses valid value', () => {
-    for (const weight of allowed) {
-      expect(fontWeightValue.safeParse(weight).success).toStrictEqual(true)
-    }
-  })
-
-  it('fails on invalid values', () => {
-    expect(fontWeightValue.safeParse(1200).success).toStrictEqual(false)
-    expect(fontWeightValue.safeParse('100').success).toStrictEqual(false)
-    expect(fontWeightValue.safeParse(false).success).toStrictEqual(false)
-  })
-})

package/src/schemas/numberTokenSchema.test.ts

@@ -1,82 +0,0 @@
-import {numberToken} from './numberToken'
-
-describe('Schema: numberToken', () => {
-  const validToken = {
-    $value: 10,
-    $type: 'number',
-    $description: 'a number token',
-  }
-
-  it('parses valid number tokens', () => {
-    expect(numberToken.safeParse(validToken).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid properties', () => {
-    // additional element
-    expect(
-      numberToken.safeParse({
-        ...validToken,
-        additional: 1000,
-      }).success,
-    ).toStrictEqual(false)
-    // missing value
-    expect(
-      numberToken.safeParse({
-        $type: 'number',
-      }).success,
-    ).toStrictEqual(false)
-    // missing type
-    expect(
-      numberToken.safeParse({
-        $value: 1000,
-      }).success,
-    ).toStrictEqual(false)
-  })
-
-  it('fails on wrong type', () => {
-    // invalid string
-    expect(
-      numberToken.safeParse({
-        ...validToken,
-        $type: 'motion',
-      }).success,
-    ).toStrictEqual(false)
-    // undefined
-    expect(
-      numberToken.safeParse({
-        ...validToken,
-        $type: undefined,
-      }).success,
-    ).toStrictEqual(false)
-    // no type
-    expect(
-      numberToken.safeParse({
-        $value: 1000,
-      }).success,
-    ).toStrictEqual(false)
-  })
-
-  it('fails on wrong value', () => {
-    // invalid string
-    expect(
-      numberToken.safeParse({
-        ...validToken,
-        $value: 'string',
-      }).success,
-    ).toStrictEqual(false)
-    // undefined
-    expect(
-      numberToken.safeParse({
-        ...validToken,
-        $value: undefined,
-      }).success,
-    ).toStrictEqual(false)
-    // boolean
-    expect(
-      numberToken.safeParse({
-        ...validToken,
-        $value: false,
-      }).success,
-    ).toStrictEqual(false)
-  })
-})

package/src/schemas/referenceValueSchema.test.ts

@@ -1,20 +0,0 @@
-import {referenceValue} from './referenceValue'
-
-describe('Schema: referenceValue', () => {
-  it('returns success on valid reference', () => {
-    expect(referenceValue.safeParse('{color.token}').success).toStrictEqual(true)
-    expect(referenceValue.safeParse('{color.token.900}').success).toStrictEqual(true)
-    expect(referenceValue.safeParse('{color.@}').success).toStrictEqual(true)
-  })
-
-  it('fails on invalid reference', () => {
-    expect(referenceValue.safeParse('color.token').success).toStrictEqual(false)
-    expect(referenceValue.safeParse('{color}').success).toStrictEqual(false)
-    expect(referenceValue.safeParse('{color.@.token}').success).toStrictEqual(false)
-    expect(referenceValue.safeParse('{}').success).toStrictEqual(false)
-    expect(referenceValue.safeParse('').success).toStrictEqual(false)
-    expect(referenceValue.safeParse(100).success).toStrictEqual(false)
-    expect(referenceValue.safeParse(false).success).toStrictEqual(false)
-    expect(referenceValue.safeParse(undefined).success).toStrictEqual(false)
-  })
-})

package/src/schemas/schema.test.ts

@@ -1,33 +0,0 @@
-import {designToken} from './designToken'
-
-describe('Schema validation', () => {
-  const validTokenJson = {
-    parent: {
-      color: {
-        $value: '#000000',
-        $type: 'color',
-        $description: 'The color black',
-      },
-      duration: {
-        $value: '1000ms',
-        $type: 'duration',
-        $description: '1000 milliseconds',
-      },
-    },
-  }
-
-  it('returns success on valid schema', () => {
-    const parsedToken = designToken.safeParse(validTokenJson)
-    expect(parsedToken.success).toStrictEqual(true)
-  })
-
-  it('returns success false on invalid schema', () => {
-    const parsedToken = designToken.safeParse({
-      color: {
-        $value: '#000000',
-        $type: 'colors',
-      },
-    })
-    expect(parsedToken.success).toStrictEqual(false)
-  })
-})

package/src/schemas/scopeTokenSchema.test.ts

@@ -1,29 +0,0 @@
-import type {ValidScope} from './scopes'
-import {scopes} from './scopes'
-
-const validScopes: ValidScope[] = ['all', 'bgColor', 'fgColor', 'borderColor', 'size', 'gap', 'radius']
-const scopeSchema = scopes(validScopes)
-
-describe('Schema: scopes', () => {
-  it('parses valid scopes', () => {
-    expect(scopeSchema.safeParse(['all']).success).toStrictEqual(true)
-    expect(scopeSchema.safeParse(['bgColor']).success).toStrictEqual(true)
-    expect(scopeSchema.safeParse(['fgColor']).success).toStrictEqual(true)
-    expect(scopeSchema.safeParse(['borderColor']).success).toStrictEqual(true)
-    expect(scopeSchema.safeParse(['size']).success).toStrictEqual(true)
-    expect(scopeSchema.safeParse(['gap']).success).toStrictEqual(true)
-    expect(scopeSchema.safeParse(['radius']).success).toStrictEqual(true)
-    expect(
-      scopeSchema.safeParse(['all', 'bgColor', 'fgColor', 'borderColor', 'size', 'gap', 'radius']).success,
-    ).toStrictEqual(true)
-    expect(scopeSchema.safeParse([]).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid scope', () => {
-    expect(scopeSchema.safeParse(['invalid']).success).toStrictEqual(false)
-    expect(scopeSchema.safeParse(['']).success).toStrictEqual(false)
-    expect(scopeSchema.safeParse([1]).success).toStrictEqual(false)
-    expect(scopeSchema.safeParse([false]).success).toStrictEqual(false)
-    expect(scopeSchema.safeParse([undefined]).success).toStrictEqual(false)
-  })
-})