@ai-sdk/rsc 2.0.47 → 2.0.49

package/src/streamable-value/create-streamable-value.test.tsx

@@ -1,179 +0,0 @@
-import { delay } from '@ai-sdk/provider-utils';
-import { convertArrayToReadableStream } from '@ai-sdk/provider-utils/test';
-import { createStreamableValue } from './create-streamable-value';
-import { STREAMABLE_VALUE_TYPE, StreamableValue } from './streamable-value';
-import { it, expect } from 'vitest';
-
-async function getRawChunks(streamableValue: StreamableValue<any, any>) {
-  const chunks = [];
-  let currentValue = streamableValue;
-
-  while (true) {
-    const { next, ...otherFields } = currentValue;
-
-    chunks.push(otherFields);
-
-    if (!next) break;
-
-    currentValue = await next;
-  }
-
-  return chunks;
-}
-
-it('should return latest value', async () => {
-  const streamableValue = createStreamableValue(1).update(2).update(3).done(4);
-
-  expect(streamableValue.value.curr).toStrictEqual(4);
-});
-
-it('should be able to stream any JSON values', async () => {
-  const streamable = createStreamableValue();
-  streamable.update({ v: 123 });
-
-  expect(streamable.value.curr).toStrictEqual({ v: 123 });
-
-  streamable.done();
-});
-
-it('should support .error()', async () => {
-  const streamable = createStreamableValue();
-  streamable.error('This is an error');
-
-  expect(streamable.value).toStrictEqual({
-    error: 'This is an error',
-    type: STREAMABLE_VALUE_TYPE,
-  });
-});
-
-it('should directly emit the final value when reading .value', async () => {
-  const streamable = createStreamableValue('1');
-  streamable.update('2');
-  streamable.update('3');
-
-  expect(streamable.value.curr).toStrictEqual('3');
-
-  streamable.done('4');
-
-  expect(streamable.value.curr).toStrictEqual('4');
-});
-
-it('should be able to append strings as patch', async () => {
-  const streamable = createStreamableValue();
-  const value = streamable.value;
-
-  streamable.update('hello');
-  streamable.update('hello world');
-  streamable.update('hello world!');
-  streamable.update('new string');
-  streamable.done('new string with patch!');
-
-  expect(await getRawChunks(value)).toStrictEqual([
-    { curr: undefined, type: STREAMABLE_VALUE_TYPE },
-    { curr: 'hello' },
-    { diff: [0, ' world'] },
-    { diff: [0, '!'] },
-    { curr: 'new string' },
-    { diff: [0, ' with patch!'] },
-  ]);
-});
-
-it('should be able to call .append() to send patches', async () => {
-  const streamable = createStreamableValue();
-  const value = streamable.value;
-
-  streamable.append('hello');
-  streamable.append(' world');
-  streamable.append('!');
-  streamable.done();
-
-  expect(await getRawChunks(value)).toStrictEqual([
-    { curr: undefined, type: STREAMABLE_VALUE_TYPE },
-    { curr: 'hello' },
-    { diff: [0, ' world'] },
-    { diff: [0, '!'] },
-    {},
-  ]);
-});
-
-it('should be able to mix .update() and .append() with optimized payloads', async () => {
-  const streamable = createStreamableValue('hello');
-  const value = streamable.value;
-
-  streamable.append(' world');
-  streamable.update('hello world!!');
-  streamable.update('some new');
-  streamable.update('some new string');
-  streamable.append(' with patch!');
-  streamable.done();
-
-  expect(await getRawChunks(value)).toStrictEqual([
-    { curr: 'hello', type: STREAMABLE_VALUE_TYPE },
-    { diff: [0, ' world'] },
-    { diff: [0, '!!'] },
-    { curr: 'some new' },
-    { diff: [0, ' string'] },
-    { diff: [0, ' with patch!'] },
-    {},
-  ]);
-});
-
-it('should behave like .update() with .append() and .done()', async () => {
-  const streamable = createStreamableValue('hello');
-  const value = streamable.value;
-
-  streamable.append(' world');
-  streamable.done('fin');
-
-  expect(await getRawChunks(value)).toStrictEqual([
-    { curr: 'hello', type: STREAMABLE_VALUE_TYPE },
-    { diff: [0, ' world'] },
-    { curr: 'fin' },
-  ]);
-});
-
-it('should be able to accept readableStream as the source', async () => {
-  const streamable = createStreamableValue(
-    convertArrayToReadableStream(['hello', ' world', '!']),
-  );
-  const value = streamable.value;
-
-  expect(await getRawChunks(value)).toStrictEqual([
-    { curr: undefined, type: STREAMABLE_VALUE_TYPE },
-    { curr: 'hello' },
-    { diff: [0, ' world'] },
-    { diff: [0, '!'] },
-    {},
-  ]);
-});
-
-it('should accept readableStream with JSON payloads', async () => {
-  const streamable = createStreamableValue(
-    convertArrayToReadableStream([{ v: 1 }, { v: 2 }, { v: 3 }]),
-  );
-  const value = streamable.value;
-
-  expect(await getRawChunks(value)).toStrictEqual([
-    { curr: undefined, type: STREAMABLE_VALUE_TYPE },
-    { curr: { v: 1 } },
-    { curr: { v: 2 } },
-    { curr: { v: 3 } },
-    {},
-  ]);
-});
-
-it('should lock the streamable if from readableStream', async () => {
-  const streamable = createStreamableValue(
-    new ReadableStream({
-      async start(controller) {
-        await delay();
-        controller.enqueue('hello');
-        controller.close();
-      },
-    }),
-  );
-
-  expect(() => streamable.update('world')).toThrowErrorMatchingInlineSnapshot(
-    '[Error: .update(): Value stream is locked and cannot be updated.]',
-  );
-});

package/src/streamable-value/read-streamable-value.ui.test.tsx

@@ -1,165 +0,0 @@
-import { delay } from '@ai-sdk/provider-utils';
-import { createStreamableValue } from './create-streamable-value';
-import { readStreamableValue } from './read-streamable-value';
-import { it, expect } from 'vitest';
-
-it('should return an async iterable', () => {
-  const streamable = createStreamableValue();
-  const result = readStreamableValue(streamable.value);
-  streamable.done();
-
-  expect(result).toBeDefined();
-  expect(result[Symbol.asyncIterator]).toBeDefined();
-});
-
-it('should support reading streamed values and errors', async () => {
-  const streamable = createStreamableValue(1);
-
-  (async () => {
-    await delay();
-    streamable.update(2);
-    await delay();
-    streamable.update(3);
-    await delay();
-    streamable.error('This is an error');
-  })();
-
-  const values = [];
-
-  try {
-    for await (const v of readStreamableValue(streamable.value)) {
-      values.push(v);
-    }
-    expect.fail('should not be reached');
-  } catch (e) {
-    expect(e).toStrictEqual('This is an error');
-  }
-
-  expect(values).toStrictEqual([1, 2, 3]);
-});
-
-it('should be able to read values asynchronously with different value types', async () => {
-  const streamable = createStreamableValue({});
-
-  (async () => {
-    await delay();
-    streamable.update([1]);
-    streamable.update(['2']);
-    streamable.done({ 3: 3 });
-  })();
-
-  const values = [];
-  for await (const v of readStreamableValue(streamable.value)) {
-    values.push(v);
-  }
-
-  expect(values).toStrictEqual([{}, [1], ['2'], { '3': 3 }]);
-});
-
-it('should be able to replay errors', async () => {
-  const streamable = createStreamableValue(0);
-
-  (async () => {
-    await delay();
-    streamable.update(1);
-    streamable.update(2);
-    streamable.error({ customErrorMessage: 'this is an error' });
-  })();
-
-  const values = [];
-
-  try {
-    for await (const v of readStreamableValue(streamable.value)) {
-      values.push(v);
-    }
-
-    expect.fail('should not be reached');
-  } catch (e) {
-    expect(e).toStrictEqual({
-      customErrorMessage: 'this is an error',
-    });
-  }
-  expect(values).toStrictEqual([0, 1, 2]);
-});
-
-it('should be able to append strings as patch', async () => {
-  const streamable = createStreamableValue();
-  const value = streamable.value;
-
-  streamable.update('hello');
-  streamable.update('hello world');
-  streamable.update('hello world!');
-  streamable.update('new string');
-  streamable.done('new string with patch!');
-
-  const values = [];
-  for await (const v of readStreamableValue(value)) {
-    values.push(v);
-  }
-
-  expect(values).toStrictEqual([
-    'hello',
-    'hello world',
-    'hello world!',
-    'new string',
-    'new string with patch!',
-  ]);
-});
-
-it('should be able to call .append() to send patches', async () => {
-  const streamable = createStreamableValue();
-  const value = streamable.value;
-
-  streamable.append('hello');
-  streamable.append(' world');
-  streamable.append('!');
-  streamable.done();
-
-  const values = [];
-  for await (const v of readStreamableValue(value)) {
-    values.push(v);
-  }
-
-  expect(values).toStrictEqual(['hello', 'hello world', 'hello world!']);
-});
-
-it('should be able to mix .update() and .append() with optimized payloads', async () => {
-  const streamable = createStreamableValue('hello');
-  const value = streamable.value;
-
-  streamable.append(' world');
-  streamable.update('hello world!!');
-  streamable.update('some new');
-  streamable.update('some new string');
-  streamable.append(' with patch!');
-  streamable.done();
-
-  const values = [];
-  for await (const v of readStreamableValue(value)) {
-    values.push(v);
-  }
-
-  expect(values).toStrictEqual([
-    'hello',
-    'hello world',
-    'hello world!!',
-    'some new',
-    'some new string',
-    'some new string with patch!',
-  ]);
-});
-
-it('should behave like .update() with .append() and .done()', async () => {
-  const streamable = createStreamableValue('hello');
-  const value = streamable.value;
-
-  streamable.append(' world');
-  streamable.done('fin');
-
-  const values = [];
-  for await (const v of readStreamableValue(value)) {
-    values.push(v);
-  }
-
-  expect(values).toStrictEqual(['hello', 'hello world', 'fin']);
-});

package/src/types.test-d.ts

@@ -1,17 +0,0 @@
-import { expectTypeOf } from 'vitest';
-import { describe, it } from 'vitest';
-import type { StreamableValue } from '.';
-
-describe('StreamableValue type', () => {
-  it('should yield a type error when assigning a wrong value', () => {
-    expectTypeOf<StreamableValue<string>>().not.toEqualTypeOf<
-      StreamableValue<boolean>
-    >();
-
-    expectTypeOf<StreamableValue<string>>().not.toEqualTypeOf<string>();
-
-    expectTypeOf<
-      StreamableValue<string>
-    >().not.toEqualTypeOf<'THIS IS NOT A STREAMABLE VALUE'>();
-  });
-});