@tanstack/start-client-core 1.20.3-alpha.1

package/src/tests/envOnly.test-d.ts

@@ -0,0 +1,34 @@
+import { expectTypeOf, test } from 'vitest'
+import { clientOnly, serverOnly } from '../envOnly'
+
+const inputFn = () => 'output'
+
+const genericInputFn = <T>(input: T) => input
+
+function overloadedFn(input: string): string
+function overloadedFn(input: number): number
+function overloadedFn(input: any) {
+  return input
+}
+
+test("clientOnly returns the function it's given", () => {
+  const outputFn = clientOnly(inputFn)
+  expectTypeOf(outputFn).toEqualTypeOf<typeof inputFn>()
+
+  const genericOutputFn = clientOnly(genericInputFn)
+  expectTypeOf(genericOutputFn).toEqualTypeOf<typeof genericInputFn>()
+
+  const overloadedOutputFn = clientOnly(overloadedFn)
+  expectTypeOf(overloadedOutputFn).toEqualTypeOf<typeof overloadedFn>()
+})
+
+test("serverOnly returns the function it's given", () => {
+  const outputFn = serverOnly(inputFn)
+  expectTypeOf(outputFn).toEqualTypeOf<typeof inputFn>()
+
+  const genericOutputFn = serverOnly(genericInputFn)
+  expectTypeOf(genericOutputFn).toEqualTypeOf<typeof genericInputFn>()
+
+  const overloadedOutputFn = serverOnly(overloadedFn)
+  expectTypeOf(overloadedOutputFn).toEqualTypeOf<typeof overloadedFn>()
+})

package/src/tests/json.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import { json } from '../json'
+
+describe('json', () => {
+  it('sets the content type to application/json and stringifies the data', async () => {
+    const data = { foo: 'bar' }
+    const response = json(data)
+
+    expect(response.headers.get('Content-Type')).toBe('application/json')
+
+    const responseClone = response.clone()
+    await expect(responseClone.text()).resolves.toEqual(JSON.stringify(data))
+
+    await expect(response.json()).resolves.toEqual(data)
+  })
+  it("doesn't override the content type if it's already set", () => {
+    const response = json(null, { headers: { 'Content-Type': 'text/plain' } })
+
+    expect(response.headers.get('Content-Type')).toBe('text/plain')
+  })
+  it('reflects passed status and statusText', () => {
+    const response = json(null, { status: 404, statusText: 'Not Found' })
+
+    expect(response.status).toBe(404)
+    expect(response.statusText).toBe('Not Found')
+  })
+  it.each<[string, HeadersInit]>([
+    ['plain object', { 'X-TYPE': 'example' }],
+    ['array', [['X-TYPE', 'example']]],
+    ['Headers', new Headers({ 'X-TYPE': 'example' })],
+  ])('merges headers from %s', (_, headers) => {
+    const response = json(null, { headers })
+
+    expect(response.headers.get('X-TYPE')).toBe('example')
+    expect(response.headers.get('Content-Type')).toBe('application/json')
+  })
+})

package/src/tests/transformer.test.tsx

@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'vitest'
+
+import { startSerializer as tf } from '../serializer'
+
+describe('transformer.stringify', () => {
+  it('should stringify dates', () => {
+    const date = new Date('2021-08-19T20:00:00.000Z')
+    expect(tf.stringify(date)).toMatchInlineSnapshot(`
+      "{"$date":"2021-08-19T20:00:00.000Z"}"
+    `)
+  })
+
+  it('should stringify undefined', () => {
+    expect(tf.stringify(undefined)).toMatchInlineSnapshot(`"{"$undefined":0}"`)
+  })
+
+  it('should stringify object foo="bar"', () => {
+    expect(tf.stringify({ foo: 'bar' })).toMatchInlineSnapshot(`
+      "{"foo":"bar"}"
+    `)
+  })
+
+  it('should stringify object foo=undefined', () => {
+    expect(tf.stringify({ foo: undefined })).toMatchInlineSnapshot(
+      `"{"foo":{"$undefined":0}}"`,
+    )
+  })
+
+  it('should stringify object foo=Date', () => {
+    const date = new Date('2021-08-19T20:00:00.000Z')
+    expect(tf.stringify({ foo: date })).toMatchInlineSnapshot(`
+      "{"foo":{"$date":"2021-08-19T20:00:00.000Z"}}"
+    `)
+  })
+
+  it('should stringify empty FormData', () => {
+    const formData = new FormData()
+    expect(tf.stringify(formData)).toMatchInlineSnapshot(`"{"$formData":{}}"`)
+  })
+
+  it('should stringify FormData with key-value pairs of foo="bar",name="Sean"', () => {
+    const formData = new FormData()
+    formData.append('foo', 'bar')
+    formData.append('name', 'Sean')
+    expect(tf.stringify(formData)).toMatchInlineSnapshot(
+      `"{"$formData":{"foo":"bar","name":"Sean"}}"`,
+    )
+  })
+  it('should stringify FormData with multiple values for the same key', () => {
+    const formData = new FormData()
+    formData.append('foo', 'bar')
+    formData.append('foo', 'baz')
+    expect(tf.stringify(formData)).toMatchInlineSnapshot(
+      `"{"$formData":{"foo":["bar","baz"]}}"`,
+    )
+  })
+
+  it('should stringify bigint', () => {
+    const bigint = BigInt('9007199254740992')
+    expect(tf.stringify(bigint)).toMatchInlineSnapshot(
+      `"{"$bigint":"9007199254740992"}"`,
+    )
+  })
+  it('should stringify object foo=bigint', () => {
+    const bigint = BigInt('9007199254740992')
+    expect(tf.stringify({ foo: bigint })).toMatchInlineSnapshot(
+      `"{"foo":{"$bigint":"9007199254740992"}}"`,
+    )
+  })
+})
+
+describe('transformer.parse', () => {
+  it('should parse dates', () => {
+    const date = new Date('2021-08-19T20:00:00.000Z')
+    const str = tf.stringify(date)
+    expect(tf.parse(str)).toEqual(date)
+  })
+
+  it('should parse undefined', () => {
+    const str = tf.stringify(undefined)
+    expect(tf.parse(str)).toBeUndefined()
+  })
+
+  it('should parse object foo="bar"', () => {
+    const obj = { foo: 'bar' }
+    const str = tf.stringify(obj)
+    expect(tf.parse(str)).toEqual(obj)
+  })
+
+  it('should parse object foo=undefined', () => {
+    const obj = { foo: undefined }
+    const str = tf.stringify(obj)
+    expect(tf.parse(str)).toEqual(obj)
+  })
+
+  it('should parse object foo=Date', () => {
+    const date = new Date('2021-08-19T20:00:00.000Z')
+    const obj = { foo: date }
+    const str = tf.stringify(obj)
+    expect(tf.parse(str)).toEqual(obj)
+  })
+
+  it('should parse empty FormData', () => {
+    const formData = new FormData()
+    const str = tf.stringify(formData)
+    const parsed = tf.parse(str) as FormData
+    expect(parsed).toBeInstanceOf(FormData)
+    expect([...parsed.entries()]).toEqual([])
+  })
+
+  it('should parse FormData with key-value pairs of foo="bar",name="Sean"', () => {
+    const formData = new FormData()
+    formData.append('foo', 'bar')
+    formData.append('name', 'Sean')
+    const str = tf.stringify(formData)
+    const parsed = tf.parse(str) as FormData
+    expect(parsed).toBeInstanceOf(FormData)
+    expect([...parsed.entries()]).toEqual([
+      ['foo', 'bar'],
+      ['name', 'Sean'],
+    ])
+  })
+  it('should parse FormData with multiple values for the same key', () => {
+    const formData = new FormData()
+    formData.append('foo', 'bar')
+    formData.append('foo', 'baz')
+    const str = tf.stringify(formData)
+    const parsed = tf.parse(str) as FormData
+    expect(parsed).toBeInstanceOf(FormData)
+    expect([...parsed.entries()]).toEqual([
+      ['foo', 'bar'],
+      ['foo', 'baz'],
+    ])
+  })
+
+  it('should parse bigint', () => {
+    const bigint = BigInt('9007199254740992')
+    const str = tf.stringify(bigint)
+    expect(tf.parse(str)).toEqual(bigint)
+  })
+  it('should parse object foo=bigint', () => {
+    const bigint = BigInt('9007199254740992')
+    const obj = { foo: bigint }
+    const str = tf.stringify(obj)
+    expect(tf.parse(str)).toEqual(obj)
+  })
+})