@primer/primitives 7.17.0-rc.61b28bca → 7.17.0-rc.9ef8a8c3

package/src/formats/javascriptEsm.test.ts

@@ -1,41 +0,0 @@
-import {javascriptEsm} from './javascriptEsm'
-import {getMockFormatterArguments} from '../test-utilities'
-import {format} from 'prettier'
-
-describe('Format: ESM', () => {
-  it('Formats tokens adding prefix', () => {
-    const input = getMockFormatterArguments({
-      platform: {
-        prefix: 'test',
-      },
-    })
-    const expectedOutput = format(
-      `export default {
-      test: {
-        tokens: {
-          subgroup: {
-            red: "transformedValue",
-          },
-        },
-      },
-    };`,
-      {parser: 'typescript', printWidth: 500},
-    )
-    expect(javascriptEsm(input)).toStrictEqual(expectedOutput)
-  })
-
-  it('Formats tokens without prefix', () => {
-    const input = getMockFormatterArguments()
-    const expectedOutput = format(
-      `export default {
-      tokens: {
-        subgroup: {
-          red: "transformedValue",
-        },
-      },
-    };`,
-      {parser: 'typescript', printWidth: 500},
-    )
-    expect(javascriptEsm(input)).toStrictEqual(expectedOutput)
-  })
-})

package/src/formats/jsonNestedPrefixed.test.ts

@@ -1,73 +0,0 @@
-import {jsonNestedPrefixed} from './jsonNestedPrefixed'
-import {getMockFormatterArguments} from '../test-utilities'
-import {format} from 'prettier'
-
-describe('Format: Json nested with prefixes', () => {
-  test('Formats tokens with prefix', () => {
-    const input = getMockFormatterArguments({
-      platform: {
-        prefix: 'test',
-      },
-    })
-
-    const expectedOutput = format(
-      `{
-        "test": {
-          "tokens": {
-            "subgroup": {
-              "red": "transformedValue"
-            }
-          }
-        }
-      }`,
-      {parser: 'json', printWidth: 500},
-    )
-
-    expect(jsonNestedPrefixed(input)).toBe(expectedOutput)
-  })
-
-  test('Formats tokens without prefix', () => {
-    const input = getMockFormatterArguments()
-    const expectedOutput = format(
-      `{
-        "tokens": {
-          "subgroup": {
-            "red": "transformedValue"
-          }
-        }
-      }`,
-      {parser: 'json', printWidth: 500},
-    )
-    expect(jsonNestedPrefixed(input)).toStrictEqual(expectedOutput)
-  })
-
-  test('Formats tokens without verbose setting', () => {
-    const input = getMockFormatterArguments({
-      options: {
-        outputVerbose: true,
-      },
-    })
-    const expectedOutput = format(
-      `{
-        "tokens": {
-          "subgroup": {
-            "red": {
-               "name": "red",
-               "path": ["tokens", "subgroup", "red"],
-               "original": {
-                 "value": "originalValue",
-                 "attributes": {}
-               },
-               "filePath": "file.json",
-               "isSource": true,
-               "value": "transformedValue",
-               "attributes": {}
-            }
-          }
-        }
-      }`,
-      {parser: 'json', printWidth: 500},
-    )
-    expect(jsonNestedPrefixed(input)).toStrictEqual(expectedOutput)
-  })
-})

package/src/formats/jsonOneDimensional.test.ts

@@ -1,56 +0,0 @@
-import {jsonOneDimensional} from './jsonOneDimensional'
-import {getMockDictionary, getMockFormatterArguments, getMockToken} from '../test-utilities'
-import {format} from 'prettier'
-
-describe('Format: Json One Dimensional', () => {
-  const dictionary = getMockDictionary({
-    tokens: {
-      subgroup: {
-        red: getMockToken({
-          name: 'tokens-subgroup-red',
-          path: ['tokens', 'subgroup', 'red'],
-        }),
-      },
-    },
-  })
-
-  test('Formats tokens as object', () => {
-    const input = getMockFormatterArguments({
-      dictionary,
-      options: {outputVerbose: true},
-    })
-
-    const expectedOutput = format(
-      `{
-        "tokens-subgroup-red": {
-          "name": "tokens-subgroup-red",
-          "path": ["tokens", "subgroup", "red"],
-          "original": {
-            "value": "originalValue",
-            "attributes": {}
-          },
-          "filePath": "file.json",
-          "isSource": true,
-          "value": "transformedValue",
-          "attributes": {}
-        }
-      }`,
-      {parser: 'json', printWidth: 500},
-    )
-    expect(jsonOneDimensional(input)).toStrictEqual(expectedOutput)
-  })
-
-  test('Formats tokens as values only', () => {
-    const input = getMockFormatterArguments({
-      dictionary,
-    })
-
-    const expectedOutput = format(
-      `{
-        "tokens-subgroup-red": "transformedValue"
-      }`,
-      {parser: 'json', printWidth: 500},
-    )
-    expect(jsonOneDimensional(input)).toStrictEqual(expectedOutput)
-  })
-})

package/src/formats/typescriptExportDefinition.test.ts

@@ -1,178 +0,0 @@
-import {typescriptExportDefinition} from './typescriptExportDefinition'
-import {getMockFormatterArguments, getMockDictionary, getMockToken} from '../test-utilities'
-import {format} from 'prettier'
-
-describe('Format: TypeScript definitions', () => {
-  const dictionary = getMockDictionary({
-    tokens: {
-      subgroup: {
-        red: getMockToken({
-          $type: 'color',
-          value: '#FF0000',
-        }),
-        stringValue: getMockToken({
-          value: '#FF0000',
-        }),
-        border: getMockToken({
-          $type: 'border',
-          value: {
-            color: '#FF0000',
-            style: 'solid',
-            width: '1px',
-          },
-        }),
-        numberValue: getMockToken({
-          value: 20,
-        }),
-        booleanValue: getMockToken({
-          value: true,
-        }),
-      },
-    },
-  })
-
-  it('Formats dimension tokens', () => {
-    const input = getMockFormatterArguments({
-      dictionary: getMockDictionary({
-        tokens: {
-          subgroup: {
-            size: {
-              px: getMockToken({
-                $type: 'dimension',
-                value: '100px',
-              }),
-              rem: getMockToken({
-                $type: 'dimension',
-                value: '10rem',
-              }),
-              em: getMockToken({
-                $type: 'dimension',
-                value: '10em',
-              }),
-            },
-          },
-        },
-      }),
-    })
-    const expectedOutput = format(
-      `/**
-        * @description size in px
-        */
-        type SizePx = \`\${number}px\`
-
-      /**
-        * @description size in rem
-        */
-        type SizeRem = \`\${number}rem\`
-
-      /**
-        * @description size in em
-        */
-        type SizeEm = \`\${number}em\`
-
-      export type tokens = {
-        tokens: {
-          subgroup: {
-            size: {
-              px: SizePx;
-              rem: SizeRem;
-              em: SizeEm;
-            };
-          };
-        };
-      };`,
-      {parser: 'typescript', printWidth: 500},
-    )
-
-    expect(typescriptExportDefinition(input)).toStrictEqual(expectedOutput)
-  })
-
-  it('Formats tokens adding prefix', () => {
-    const input = getMockFormatterArguments({
-      dictionary,
-      platform: {
-        prefix: 'test',
-      },
-    })
-    const expectedOutput = format(
-      `/**
-       * @description hex string (6 or 8-digit)
-       */
-      type ColorHex = string;
-
-      /**
-       * @description a css border string
-       * @format color | style | width
-       */
-      type Border = \`\${ColorHex} \${string} \${string}\`;
-
-      export type tokens = {
-        test: {
-          tokens: {
-            subgroup: {
-              red: ColorHex;
-              stringValue: string;
-              border: Border;
-              numberValue: number;
-              booleanValue: "boolean";
-            };
-          };
-        };
-      };`,
-      {parser: 'typescript', printWidth: 500},
-    )
-
-    expect(typescriptExportDefinition(input)).toStrictEqual(expectedOutput)
-  })
-
-  it('Formats tokens without prefix', () => {
-    const input = getMockFormatterArguments({dictionary})
-    const expectedOutput = format(
-      `/**
-      * @description hex string (6 or 8-digit)
-      */
-      type ColorHex = string;
-
-      /**
-       * @description a css border string
-       * @format color | style | width
-       */
-      type Border = \`\${ColorHex} \${string} \${string}\`;
-
-      export type tokens = {
-        tokens: {
-          subgroup: {
-            red: ColorHex;
-            stringValue: string;
-            border: Border;
-            numberValue: number;
-            booleanValue: "boolean";
-          };
-        };
-      };`,
-      {parser: 'typescript', printWidth: 500},
-    )
-    expect(typescriptExportDefinition(input)).toStrictEqual(expectedOutput)
-  })
-
-  it('throws an invalidTokenValue error if a token has an invalid value for the defined type', () => {
-    const input = getMockFormatterArguments({
-      dictionary: getMockDictionary({
-        // @ts-expect-error: Because of invalid token
-        tokens: {
-          subgroup: {
-            color: {
-              name: 'color token name',
-              value: 'rgb(100,200,255)',
-              $type: 'color',
-            },
-          },
-        },
-      }),
-    })
-
-    expect(() => {
-      typescriptExportDefinition(input)
-    }).toThrowError('Invalid token: "color token name" with type "color" can not have a value of "rgb(100,200,255)"')
-  })
-})

package/src/formats/utilities/jsonToFlat.test.ts

@@ -1,47 +0,0 @@
-import {getMockToken} from '../../test-utilities'
-import {jsonToFlat} from './jsonToFlat'
-
-describe('Utilities: jsonToFlat', () => {
-  const tokens = [
-    getMockToken({
-      value: '#111',
-      $type: 'color',
-      path: ['parent', 'subparent', 'child1'],
-      name: 'parent-subparent-child1',
-    }),
-    getMockToken({
-      value: '#222',
-      $type: 'color',
-      path: ['parent', 'subparent', 'child2'],
-      name: 'parent-subparent-child2',
-    }),
-  ]
-
-  it('it returns only value property as value of object if return Object is false', () => {
-    expect(jsonToFlat(tokens, false)['parent-subparent-child1']).toBe('#111')
-    expect(jsonToFlat(tokens, false)).toStrictEqual({
-      'parent-subparent-child1': '#111',
-      'parent-subparent-child2': '#222',
-    })
-  })
-
-  it('it returns objects as value of object if return Object is true', () => {
-    expect(jsonToFlat(tokens, true)['parent-subparent-child1']).toEqual({
-      value: '#111',
-      $type: 'color',
-      path: ['parent', 'subparent', 'child1'],
-      name: 'parent-subparent-child1',
-      attributes: {},
-      filePath: 'file.json',
-      isSource: true,
-      original: {
-        attributes: {},
-        value: 'originalValue',
-      },
-    })
-  })
-
-  it('it returns only value property as value of object if return Object is undefined', () => {
-    expect(jsonToFlat(tokens, undefined)['parent-subparent-child1']).toBe('#111')
-  })
-})

package/src/formats/utilities/jsonToNestedValue.test.ts

@@ -1,39 +0,0 @@
-import {jsonToNestedValue} from './jsonToNestedValue'
-
-describe('Utilities: jsonToNestedValue', () => {
-  const obj = {
-    parent: {
-      subparent: {
-        child1: {
-          value: '#111',
-          $type: 'color',
-        },
-        child2: {
-          value: '#222',
-          $type: 'color',
-        },
-      },
-      otherSubparent: {
-        text: 'hello',
-        number: 42,
-        noValue: {
-          string: 'string',
-          number: 12,
-        },
-      },
-    },
-  }
-
-  it('it returns only value property as value of object', () => {
-    expect(jsonToNestedValue(obj.parent.subparent.child1)).toBe('#111')
-    expect(jsonToNestedValue(obj['parent']['subparent'])).toStrictEqual({child1: '#111', child2: '#222'})
-  })
-
-  it('it returns only values if final child is no object', () => {
-    const transformedObj = obj
-    // @ts-expect-error: fake token for test causes error
-    transformedObj['parent']['subparent'] = {child1: '#111', child2: '#222'}
-
-    expect(jsonToNestedValue(obj)).toStrictEqual(transformedObj)
-  })
-})

package/src/formats/utilities/prefixTokens.test.ts

@@ -1,38 +0,0 @@
-import {getMockToken} from '../../test-utilities'
-import {prefixTokens} from './prefixTokens'
-
-describe('Utilities: prefixTokens', () => {
-  const tokens = {
-    colors: getMockToken({
-      name: 'token',
-      value: 'value',
-    }),
-  }
-
-  it('it adds prefix to token array', () => {
-    const platform = {
-      prefix: 'pumpkin',
-    }
-    const expectedOutput = {
-      [platform.prefix]: tokens,
-    }
-
-    expect(prefixTokens(tokens, platform)).toStrictEqual(expectedOutput)
-  })
-
-  it('it returns original token array if prefix is undefined', () => {
-    const platform = {
-      prefix: undefined,
-    }
-    const expectedOutput = tokens
-
-    expect(prefixTokens(tokens, platform)).toStrictEqual(expectedOutput)
-  })
-
-  it('it returns original token array if platform is undefined', () => {
-    const platform = undefined
-    const expectedOutput = tokens
-
-    expect(prefixTokens(tokens, platform)).toStrictEqual(expectedOutput)
-  })
-})

package/src/parsers/w3cJsonParser.test.ts

@@ -1,35 +0,0 @@
-import {w3cJsonParser} from './w3cJsonParser'
-import {parserOutput as expectedOutput, getMockParserInput} from '../test-utilities'
-
-describe('Parser: w3c token json5 parser', () => {
-  it('parses valid w3c json5', () => {
-    const result = w3cJsonParser.parse(getMockParserInput('json5.w3c'))
-    expect(result).toStrictEqual(expectedOutput)
-  })
-
-  it('parses valid w3c json', () => {
-    const result = w3cJsonParser.parse(getMockParserInput('json.w3c'))
-    expect(result).toStrictEqual(expectedOutput)
-  })
-
-  it('parses valid json5', () => {
-    const result = w3cJsonParser.parse(getMockParserInput('json5.default'))
-    expect(result).toStrictEqual(expectedOutput)
-  })
-
-  it('parses valid json', () => {
-    const result = w3cJsonParser.parse(getMockParserInput('json.default'))
-    expect(result).toStrictEqual(expectedOutput)
-  })
-
-  it('it parses empty object `{}` json', () => {
-    const result = w3cJsonParser.parse(getMockParserInput('{}'))
-    expect(result).toStrictEqual({})
-  })
-
-  it('throws an error while parsing invalid empty JSON', () => {
-    expect(() => {
-      w3cJsonParser.parse(getMockParserInput('', 'invalidFile.json'))
-    }).toThrow(`Invalid json5 file "invalidFile.json".`)
-  })
-})

package/src/schemas/alphaValueSchema.test.ts

@@ -1,24 +0,0 @@
-import {alphaValue} from './alphaValue'
-
-describe('Schema: alphaValue', () => {
-  it('passes on valid alpha values', () => {
-    expect(alphaValue.safeParse(0).success).toStrictEqual(true)
-    expect(alphaValue.safeParse(0.5).success).toStrictEqual(true)
-    expect(alphaValue.safeParse(0.23455).success).toStrictEqual(true)
-    expect(alphaValue.safeParse(1).success).toStrictEqual(true)
-    expect(alphaValue.safeParse(1.0).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid alpha values', () => {
-    expect(alphaValue.safeParse(-1).success).toStrictEqual(false)
-    expect(alphaValue.safeParse(-0.1).success).toStrictEqual(false)
-    expect(alphaValue.safeParse(1.1).success).toStrictEqual(false)
-  })
-
-  it('fails on non-numeric values', () => {
-    expect(alphaValue.safeParse('1').success).toStrictEqual(false)
-    expect(alphaValue.safeParse(undefined).success).toStrictEqual(false)
-    expect(alphaValue.safeParse(null).success).toStrictEqual(false)
-    expect(alphaValue.safeParse('').success).toStrictEqual(false)
-  })
-})

package/src/schemas/baseTokenSchema.test.ts

@@ -1,17 +0,0 @@
-import {baseToken} from './baseToken'
-
-describe('Schema: baseToken', () => {
-  const validToken = {
-    $description: 'a base token',
-  }
-
-  it('passes on valid values', () => {
-    expect(baseToken.safeParse(validToken).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid property', () => {
-    expect(baseToken.safeParse({...validToken, $type: 'stroke'}).success).toStrictEqual(false)
-    expect(baseToken.safeParse({...validToken, $value: 'wrong'}).success).toStrictEqual(false)
-    expect(baseToken.safeParse({...validToken, $additional: undefined}).success).toStrictEqual(false)
-  })
-})

package/src/schemas/borderTokenSchema.test.ts

@@ -1,53 +0,0 @@
-import {borderToken, borderValue} from './borderToken'
-
-const validBorderValue = {
-  color: '#333',
-  style: 'solid',
-  width: '1px',
-}
-
-describe('Schema: borderValue', () => {
-  it('passes on valid values', () => {
-    expect(borderValue.safeParse(validBorderValue).success).toStrictEqual(true)
-  })
-
-  it('passes on valid stroke values', () => {
-    expect(borderValue.safeParse({...validBorderValue, style: 'solid'}).success).toStrictEqual(true)
-    expect(borderValue.safeParse({...validBorderValue, style: 'dashed'}).success).toStrictEqual(true)
-    expect(borderValue.safeParse({...validBorderValue, style: 'dotted'}).success).toStrictEqual(true)
-    expect(borderValue.safeParse({...validBorderValue, style: 'double'}).success).toStrictEqual(true)
-    expect(borderValue.safeParse({...validBorderValue, style: 'groove'}).success).toStrictEqual(true)
-    expect(borderValue.safeParse({...validBorderValue, style: 'ridge'}).success).toStrictEqual(true)
-    expect(borderValue.safeParse({...validBorderValue, style: 'outset'}).success).toStrictEqual(true)
-    expect(borderValue.safeParse({...validBorderValue, style: 'inset'}).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid values', () => {
-    expect(borderValue.safeParse({...validBorderValue, style: 'none'}).success).toStrictEqual(false)
-    expect(borderValue.safeParse({...validBorderValue, color: 'none'}).success).toStrictEqual(false)
-    expect(borderValue.safeParse({...validBorderValue, width: '1%'}).success).toStrictEqual(false)
-    expect(borderValue.safeParse({...validBorderValue, width: '1vw'}).success).toStrictEqual(false)
-  })
-
-  it('fails on missing values', () => {
-    expect(borderValue.safeParse({...validBorderValue, style: undefined}).success).toStrictEqual(false)
-    expect(borderValue.safeParse({...validBorderValue, color: undefined}).success).toStrictEqual(false)
-    expect(borderValue.safeParse({...validBorderValue, width: undefined}).success).toStrictEqual(false)
-  })
-})
-
-describe('Schema: borderToken', () => {
-  const validBorderToken = {
-    $value: validBorderValue,
-    $type: 'border',
-    $description: 'a border token',
-  }
-
-  it('passes on valid values', () => {
-    expect(borderToken.safeParse(validBorderToken).success).toStrictEqual(true)
-  })
-
-  it('fails on invalid type', () => {
-    expect(borderToken.safeParse({...validBorderToken, $type: 'stroke'}).success).toStrictEqual(false)
-  })
-})

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)
-  })
-})