@blueprint-ts/core 4.1.0-beta.1 → 4.1.0-beta.3

package/tests/service/requests/BaseRequest.test.ts

@@ -1,250 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { BaseRequest } from '../../../src/requests/BaseRequest'
-import { BaseResponse } from '../../../src/requests/responses/BaseResponse'
-import { JsonBodyFactory } from '../../../src/requests/factories/JsonBodyFactory'
-import { RequestMethodEnum } from '../../../src/requests/RequestMethod.enum'
-import { RequestEvents } from '../../../src/requests/RequestEvents.enum'
-import { RequestConcurrencyMode } from '../../../src/requests/RequestConcurrencyMode.enum'
-import { StaleResponseException } from '../../../src/requests/exceptions/StaleResponseException'
-import { ResponseException } from '../../../src/requests/exceptions/ResponseException'
-import { ErrorHandler } from '../../../src/requests/ErrorHandler'
-import type { RequestDriverContract } from '../../../src/requests/contracts/RequestDriverContract'
-import type { RequestLoaderContract } from '../../../src/requests/contracts/RequestLoaderContract'
-import type { RequestLoaderFactoryContract } from '../../../src/requests/contracts/RequestLoaderFactoryContract'
-import type { ResponseHandlerContract } from '../../../src/requests/drivers/contracts/ResponseHandlerContract'
-
-class TestResponse extends BaseResponse<string> {
-  public getAcceptHeader(): string {
-    return 'text/plain'
-  }
-
-  protected resolveBody(): Promise<string> {
-    return Promise.resolve('ok')
-  }
-}
-
-class TestLoader implements RequestLoaderContract<boolean> {
-  private loading = false
-
-  isLoading(): boolean {
-    return this.loading
-  }
-
-  setLoading(value: boolean): void {
-    this.loading = value
-  }
-}
-
-class TestRequest extends BaseRequest<boolean, { message: string }, string, TestResponse, { name: string }, { filter?: { active?: boolean } }> {
-  public method(): RequestMethodEnum {
-    return RequestMethodEnum.POST
-  }
-
-  public url(): string {
-    return '/test'
-  }
-
-  public getResponse(): TestResponse {
-    return new TestResponse()
-  }
-
-  public requestHeaders() {
-    return { 'X-Req': 'value' }
-  }
-
-  public getRequestBodyFactory() {
-    return new JsonBodyFactory<{ name: string }>()
-  }
-}
-
-const createResponseHandler = (): ResponseHandlerContract => ({
-  getStatusCode: () => 200,
-  getHeaders: () => ({}),
-  getRawResponse: () => new Response('ok'),
-  json: async () => ({ ok: true }),
-  text: async () => 'ok',
-  blob: async () => new Blob(),
-})
-
-describe('BaseRequest', () => {
-  beforeEach(() => {
-    BaseRequest.setDefaultBaseUrl('https://example.com')
-    BaseRequest.setRequestLoaderFactory(undefined as unknown as RequestLoaderFactoryContract<boolean>)
-    BaseRequest.setRequestDriver(undefined as unknown as RequestDriverContract)
-  })
-
-  it('builds URLs with params and merges params deeply', () => {
-    const request = new TestRequest()
-
-    request.setParams({ filter: { active: true } })
-    request.withParams({ filter: { active: false } })
-
-    expect(request.getParams()).toEqual({ filter: { active: false } })
-
-    const url = request.buildUrl()
-    expect(url.toString()).toBe('https://example.com/test?filter%5Bactive%5D=false')
-  })
-
-  it('dispatches loading events and toggles loader', async () => {
-    const loaderFactory: RequestLoaderFactoryContract<boolean> = {
-      make: () => new TestLoader(),
-    }
-
-    BaseRequest.setRequestLoaderFactory(loaderFactory)
-
-    const driver: RequestDriverContract = {
-      send: vi.fn().mockResolvedValue(createResponseHandler()),
-    }
-    BaseRequest.setRequestDriver(driver)
-
-    const request = new TestRequest()
-    const loadingEvents: boolean[] = []
-
-    request.on(RequestEvents.LOADING, (value: boolean) => loadingEvents.push(value))
-    request.setBody({ name: 'Ada' })
-
-    const response = await request.send()
-
-    expect(response.getBody()).toBe('ok')
-    expect(loadingEvents).toEqual([true, false])
-    expect(request.isLoading()).toBe(false)
-
-    expect(driver.send).toHaveBeenCalledTimes(1)
-
-    const [url, method, headers, body] = (driver.send as ReturnType<typeof vi.fn>).mock.calls[0]
-    expect(url.toString()).toBe('https://example.com/test')
-    expect(method).toBe(RequestMethodEnum.POST)
-    expect(headers).toEqual({ Accept: 'text/plain', 'X-Req': 'value' })
-    expect(body?.getContent()).toBe('{"name":"Ada"}')
-  })
-
-  it('dispatches upload progress events from the driver config callback', async () => {
-    const driver: RequestDriverContract = {
-      send: vi.fn().mockImplementation(async (_url, _method, _headers, _body, requestConfig) => {
-        requestConfig?.onUploadProgress?.({
-          loaded: 5,
-          total: 10,
-          lengthComputable: true,
-          progress: 0.5,
-        })
-
-        return createResponseHandler()
-      }),
-    }
-
-    BaseRequest.setRequestDriver(driver)
-
-    const request = new TestRequest()
-    const progressEvents: Array<number | undefined> = []
-
-    request.on(RequestEvents.UPLOAD_PROGRESS, (value: { progress?: number }) => progressEvents.push(value.progress))
-    request.setBody({ name: 'Ada' })
-
-    await request.send()
-
-    expect(progressEvents).toEqual([0.5])
-  })
-
-  it('throws when loading state is requested without a loader', () => {
-    const request = new TestRequest()
-
-    expect(() => request.isLoading()).toThrow('Request loader is not set.')
-  })
-
-  it('marks stale responses when using LATEST concurrency mode', async () => {
-    const driver: RequestDriverContract = {
-      send: vi.fn(),
-    }
-    BaseRequest.setRequestDriver(driver)
-
-    const resolvers: Array<(value: ResponseHandlerContract) => void> = []
-
-    ;(driver.send as ReturnType<typeof vi.fn>).mockImplementation(() =>
-      new Promise<ResponseHandlerContract>((resolve) => {
-        resolvers.push(resolve)
-      })
-    )
-
-    const request = new TestRequest()
-    request.setConcurrency({ mode: RequestConcurrencyMode.LATEST, key: 'latest-test' })
-
-    const first = request.send()
-    const second = request.send()
-
-    resolvers[1](createResponseHandler())
-    await expect(second).resolves.toBeInstanceOf(TestResponse)
-
-    resolvers[0](createResponseHandler())
-    await expect(first).rejects.toBeInstanceOf(StaleResponseException)
-  })
-
-  it('aborts previous request when using REPLACE mode', async () => {
-    const driver: RequestDriverContract = {
-      send: vi.fn(),
-    }
-    BaseRequest.setRequestDriver(driver)
-
-    const request = new TestRequest()
-    request.setConcurrency({ mode: RequestConcurrencyMode.REPLACE, key: 'replace-test' })
-
-    const resolvers: Array<(value: ResponseHandlerContract) => void> = []
-    ;(driver.send as ReturnType<typeof vi.fn>).mockImplementation(() =>
-      new Promise<ResponseHandlerContract>((resolve) => {
-        resolvers.push(resolve)
-      })
-    )
-
-    const firstPromise = request.send()
-    const firstConfig = (driver.send as ReturnType<typeof vi.fn>).mock.calls[0][4]
-
-    const secondPromise = request.send()
-
-    expect(firstConfig?.abortSignal?.aborted).toBe(true)
-
-    resolvers[0](createResponseHandler())
-    resolvers[1](createResponseHandler())
-
-    await Promise.allSettled([firstPromise, secondPromise])
-  })
-
-  it('invokes ErrorHandler when a ResponseException is thrown', async () => {
-    const responseHandler = createResponseHandler()
-    const responseException = new ResponseException(responseHandler)
-
-    const driver: RequestDriverContract = {
-      send: vi.fn().mockRejectedValue(responseException),
-    }
-    BaseRequest.setRequestDriver(driver)
-
-    const handleSpy = vi.spyOn(ErrorHandler.prototype, 'handle').mockResolvedValue(undefined as never)
-
-    const request = new TestRequest()
-
-    await expect(request.send()).rejects.toBe(responseException)
-    expect(handleSpy).toHaveBeenCalledTimes(1)
-  })
-
-  it('uses a request-defined driver when provided', async () => {
-    const globalDriver: RequestDriverContract = {
-      send: vi.fn().mockResolvedValue(createResponseHandler()),
-    }
-    const requestDriver: RequestDriverContract = {
-      send: vi.fn().mockResolvedValue(createResponseHandler()),
-    }
-
-    BaseRequest.setRequestDriver(globalDriver)
-
-    class DriverSpecificRequest extends TestRequest {
-      protected override getRequestDriver(): RequestDriverContract {
-        return requestDriver
-      }
-    }
-
-    const request = new DriverSpecificRequest()
-
-    await request.send()
-
-    expect(requestDriver.send).toHaveBeenCalledTimes(1)
-    expect(globalDriver.send).not.toHaveBeenCalled()
-  })
-})

package/tests/service/requests/BodiesAndFactories.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { JsonBody } from '../../../src/requests/bodies/JsonBody'
-import { JsonBodyFactory } from '../../../src/requests/factories/JsonBodyFactory'
-import { FormDataFactory } from '../../../src/requests/factories/FormDataFactory'
-import { FormDataBody } from '../../../src/requests/bodies/FormDataBody'
-
-describe('Request bodies and factories', () => {
-  it('JsonBody returns headers and JSON content', () => {
-    const body = new JsonBody({ hello: 'world' })
-
-    expect(body.getHeaders()).toEqual({ 'Content-Type': 'application/json' })
-    expect(body.getContent()).toBe('{"hello":"world"}')
-  })
-
-  it('JsonBodyFactory returns JsonBody', () => {
-    const factory = new JsonBodyFactory<{ foo: string }>()
-    const body = factory.make({ foo: 'bar' })
-
-    expect(body).toBeInstanceOf(JsonBody)
-  })
-
-  it('FormDataFactory returns FormDataBody', () => {
-    const factory = new FormDataFactory<{ name: string }>()
-    const body = factory.make({ name: 'alice' })
-
-    expect(body).toBeInstanceOf(FormDataBody)
-  })
-})

package/tests/service/requests/Enums.test.ts

@@ -1,20 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { RequestMethodEnum } from '../../../src/requests/RequestMethod.enum'
-import { RequestEvents } from '../../../src/requests/RequestEvents.enum'
-import { RequestConcurrencyMode } from '../../../src/requests/RequestConcurrencyMode.enum'
-import { BulkRequestExecutionMode } from '../../../src/bulkRequests/BulkRequestSender'
-
-
-describe('Enums', () => {
-  it('exposes expected request enums', () => {
-    expect(RequestMethodEnum.GET).toBe('GET')
-    expect(RequestEvents.LOADING).toBe('loading')
-    expect(RequestEvents.UPLOAD_PROGRESS).toBe('upload-progress')
-    expect(RequestConcurrencyMode.REPLACE_LATEST).toBe('replace-latest')
-  })
-
-  it('exposes bulk request execution modes', () => {
-    expect(BulkRequestExecutionMode.PARALLEL).toBe('parallel')
-    expect(BulkRequestExecutionMode.SEQUENTIAL).toBe('sequential')
-  })
-})

package/tests/service/requests/ErrorHandler.test.ts

@@ -1,188 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ErrorHandler } from '../../../src/requests'
-
-import {
-  PageExpiredException,
-  NotFoundException,
-  UnauthorizedException,
-  ValidationException,
-  ResponseException,
-  NoResponseReceivedException,
-  ServerErrorException,
-  InvalidJsonException,
-  BadRequestException,
-  ForbiddenException,
-  MethodNotAllowedException,
-  RequestTimeoutException,
-  ConflictException,
-  GoneException,
-  PreconditionFailedException,
-  PayloadTooLargeException,
-  UnsupportedMediaTypeException,
-  LockedException,
-  TooManyRequestsException,
-  NotImplementedException,
-  BadGatewayException,
-  ServiceUnavailableException,
-  GatewayTimeoutException
-} from '../../../src/requests/exceptions';
-
-describe('ErrorHandler', () => {
-  beforeEach(() => {
-    ErrorHandler.registerHandler(undefined);
-  });
-
-  it('should throw UnauthorizedException for status code 401', async () => {
-    const mockResponse = {
-      getStatusCode: vi.fn().mockReturnValue(401),
-      json: vi.fn().mockResolvedValue({}),
-    };
-
-    const handler = new ErrorHandler(mockResponse as any)
-
-    await expect(handler.handle()).rejects.toThrow(UnauthorizedException);
-
-    expect(mockResponse.getStatusCode).toHaveBeenCalled();
-    expect(mockResponse.json).toHaveBeenCalled();
-  });
-
-  it('should throw NotFoundException for status code 404', async () => {
-    const mockResponse = {
-      getStatusCode: vi.fn().mockReturnValue(404),
-      json: vi.fn().mockResolvedValue({}),
-    };
-
-    const handler = new ErrorHandler(mockResponse as any)
-
-    await expect(handler.handle()).rejects.toThrow(NotFoundException);
-
-    expect(mockResponse.getStatusCode).toHaveBeenCalled();
-    expect(mockResponse.json).toHaveBeenCalled();
-  });
-
-  it('should throw PageExpiredException for status code 419', async () => {
-    const mockResponse = {
-      getStatusCode: vi.fn().mockReturnValue(419),
-      json: vi.fn().mockResolvedValue({}),
-    };
-
-    const handler = new ErrorHandler(mockResponse as any)
-
-    await expect(handler.handle()).rejects.toThrow(PageExpiredException);
-
-    expect(mockResponse.getStatusCode).toHaveBeenCalled();
-    expect(mockResponse.json).toHaveBeenCalled();
-  });
-
-  it('should throw ValidationException for status code 422', async () => {
-    const mockResponse = {
-      getStatusCode: vi.fn().mockReturnValue(422),
-      json: vi.fn().mockResolvedValue({}),
-    };
-
-    const handler = new ErrorHandler(mockResponse as any)
-
-    await expect(handler.handle()).rejects.toThrow(ValidationException);
-
-    expect(mockResponse.getStatusCode).toHaveBeenCalled();
-    expect(mockResponse.json).toHaveBeenCalled();
-  });
-
-  it('should throw ServerErrorException for status code 500', async () => {
-    const mockResponse = {
-      getStatusCode: vi.fn().mockReturnValue(500),
-      json: vi.fn().mockResolvedValue({}),
-    };
-
-    const handler = new ErrorHandler(mockResponse as any)
-
-    await expect(handler.handle()).rejects.toThrow(ServerErrorException);
-
-    expect(mockResponse.getStatusCode).toHaveBeenCalled();
-    expect(mockResponse.json).toHaveBeenCalled();
-  });
-
-  it('should throw NoResponseReceivedException if response body is undefined', async () => {
-    const mockResponse = {
-      getStatusCode: vi.fn().mockReturnValue(undefined),
-      json: vi.fn().mockResolvedValue(undefined),
-    };
-
-    const handler = new ErrorHandler(mockResponse as any)
-
-    await expect(handler.handle()).rejects.toThrow(NoResponseReceivedException);
-    expect(mockResponse.json).toHaveBeenCalled();
-  });
-
-  it('should throw ResponseException for other status codes', async () => {
-    const mockResponse = {
-      getStatusCode: vi.fn().mockReturnValue(499),
-      json: vi.fn().mockResolvedValue({}),
-    };
-
-    const handler = new ErrorHandler(mockResponse as any)
-
-    await expect(handler.handle()).rejects.toThrow(ResponseException);
-
-    expect(mockResponse.getStatusCode).toHaveBeenCalled();
-    expect(mockResponse.json).toHaveBeenCalled();
-  });
-
-  it('should correctly use global error handler if registered', async () => {
-    const handlerMock = vi.fn().mockReturnValue(false);
-    ErrorHandler.registerHandler(handlerMock);
-
-    const mockResponse = {
-      getStatusCode: vi.fn().mockReturnValue(500),
-      json: vi.fn().mockResolvedValue({}),
-    };
-
-    const handler = new ErrorHandler(mockResponse as any)
-
-    await expect(handler.handle()).resolves.toBeUndefined();
-
-    expect(handlerMock).toHaveBeenCalledWith(mockResponse);
-    expect(mockResponse.json).not.toHaveBeenCalled();
-  });
-
-  it('should throw InvalidJsonException when response parsing fails', async () => {
-    const mockResponse = {
-      getStatusCode: vi.fn().mockReturnValue(500),
-      json: vi.fn().mockRejectedValue(new Error('Invalid JSON')),
-    };
-
-    const handler = new ErrorHandler(mockResponse as any)
-
-    await expect(handler.handle()).rejects.toThrow(InvalidJsonException);
-    expect(mockResponse.json).toHaveBeenCalled();
-  });
-
-  it.each([
-    [400, BadRequestException],
-    [403, ForbiddenException],
-    [405, MethodNotAllowedException],
-    [408, RequestTimeoutException],
-    [409, ConflictException],
-    [410, GoneException],
-    [412, PreconditionFailedException],
-    [413, PayloadTooLargeException],
-    [415, UnsupportedMediaTypeException],
-    [423, LockedException],
-    [429, TooManyRequestsException],
-    [501, NotImplementedException],
-    [502, BadGatewayException],
-    [503, ServiceUnavailableException],
-    [504, GatewayTimeoutException],
-  ])('should throw correct exception for status code %i', async (status, ExceptionType) => {
-    const mockResponse = {
-      getStatusCode: vi.fn().mockReturnValue(status),
-      json: vi.fn().mockResolvedValue({}),
-    };
-
-    const handler = new ErrorHandler(mockResponse as any);
-
-    await expect(handler.handle()).rejects.toThrow(ExceptionType);
-    expect(mockResponse.getStatusCode).toHaveBeenCalled();
-    expect(mockResponse.json).toHaveBeenCalled();
-  });
-});

package/tests/service/requests/FormDataBody.test.ts

@@ -1,63 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { FormDataBody } from '../../../src/requests/bodies/FormDataBody'
-
-describe('FormDataBody', () => {
-  it('appends strings and files', () => {
-    const file = new File(['abc'], 'credentials.kdbx', { type: 'application/octet-stream' })
-
-    const body = new FormDataBody({
-      name: 'aerg',
-      type: 'kdbx',
-      password: 'aerg',
-      file,
-    })
-
-    const fd = body.getContent()
-
-    expect(fd.get('name')).toBe('aerg')
-    expect(fd.get('type')).toBe('kdbx')
-    expect(fd.get('password')).toBe('aerg')
-    expect(fd.get('file')).toBe(file)
-  })
-
-  it('encodes null as empty string (key present)', () => {
-    const body = new FormDataBody({
-      name: 'aerg',
-      file: null,
-    })
-
-    const fd = body.getContent()
-    expect(fd.get('name')).toBe('aerg')
-    expect(fd.get('file')).toBe('')
-  })
-
-  it('rejects undefined values (should not be silently dropped)', () => {
-    expect(
-      () =>
-        new FormDataBody({
-          missing: undefined,
-        } as any),
-    ).toThrow()
-  })
-
-  it('stringifies number/boolean values', () => {
-    const body = new FormDataBody({
-      count: 3,
-      enabled: false,
-    })
-
-    const fd = body.getContent()
-    expect(fd.get('count')).toBe('3')
-    expect(fd.get('enabled')).toBe('false')
-  })
-
-  it('supports arrays via bracket notation', () => {
-    const body = new FormDataBody({
-      tags: ['a', 'b'],
-    })
-
-    const fd = body.getContent()
-    expect(fd.get('tags[0]')).toBe('a')
-    expect(fd.get('tags[1]')).toBe('b')
-  })
-})

package/tests/service/requests/RequestErrorRouter.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { RequestErrorRouter } from '../../../src/requests/RequestErrorRouter'
-import { BadRequestException } from '../../../src/requests/exceptions/BadRequestException'
-
-const mockResponse = {
-  getStatusCode: () => 400,
-  getHeaders: () => ({}),
-  getRawResponse: () => new Response(),
-  json: async () => ({}),
-  text: async () => '',
-  blob: async () => new Blob(),
-}
-
-describe('RequestErrorRouter', () => {
-  it('routes known errors to handlers', async () => {
-    const router = new RequestErrorRouter()
-    const handler = vi.fn()
-
-    router.on(BadRequestException, handler)
-
-    const handled = await router.handle(new BadRequestException(mockResponse as any, { message: 'bad' }))
-
-    expect(handled).toBe(true)
-    expect(handler).toHaveBeenCalledTimes(1)
-  })
-
-  it('uses default handler when no match found', async () => {
-    const router = new RequestErrorRouter()
-    const fallback = vi.fn()
-
-    router.otherwise(fallback)
-
-    const handled = await router.handle(new Error('other'))
-
-    expect(handled).toBe(true)
-    expect(fallback).toHaveBeenCalledTimes(1)
-  })
-
-  it('returns false when no handlers are registered', async () => {
-    const router = new RequestErrorRouter()
-
-    await expect(router.handle(new Error('nope'))).resolves.toBe(false)
-  })
-})

package/tests/service/requests/Responses.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { BaseResponse } from '../../../src/requests/responses/BaseResponse'
-import { JsonResponse } from '../../../src/requests/responses/JsonResponse'
-import { PlainTextResponse } from '../../../src/requests/responses/PlainTextResponse'
-import { BlobResponse } from '../../../src/requests/responses/BlobResponse'
-import type { ResponseHandlerContract } from '../../../src/requests/drivers/contracts/ResponseHandlerContract'
-
-class TestResponse extends BaseResponse<string> {
-  public getAcceptHeader(): string {
-    return 'text/plain'
-  }
-
-  protected resolveBody(): Promise<string> {
-    return Promise.resolve('ok')
-  }
-}
-
-const mockResponseHandler: ResponseHandlerContract = {
-  getStatusCode: () => 200,
-  getHeaders: () => ({ 'x-test': 'yes' }),
-  getRawResponse: () => new Response('raw'),
-  json: async () => ({ ok: true }),
-  text: async () => 'plain',
-  blob: async () => new Blob(['blob'], { type: 'text/plain' }),
-}
-
-describe('Response classes', () => {
-  it('BaseResponse throws if body not set', () => {
-    const response = new TestResponse()
-
-    expect(() => response.getBody()).toThrow('Response body is not set')
-  })
-
-  it('BaseResponse stores response metadata and body', async () => {
-    const response = new TestResponse()
-
-    await response.setResponse(mockResponseHandler)
-
-    expect(response.getBody()).toBe('ok')
-    expect(response.getStatusCode()).toBe(200)
-    expect(response.getHeaders()).toEqual({ 'x-test': 'yes' })
-    expect(response.getRawResponse()).toBeInstanceOf(Response)
-  })
-
-  it('JsonResponse resolves JSON body', async () => {
-    const response = new JsonResponse<{ ok: boolean }>()
-
-    await response.setResponse(mockResponseHandler)
-
-    expect(response.getAcceptHeader()).toBe('application/json')
-    expect(response.getBody()).toEqual({ ok: true })
-  })
-
-  it('PlainTextResponse resolves text body', async () => {
-    const response = new PlainTextResponse()
-
-    await response.setResponse(mockResponseHandler)
-
-    expect(response.getAcceptHeader()).toBe('text/plain')
-    expect(response.getBody()).toBe('plain')
-  })
-
-  it('BlobResponse resolves blob body and uses mime type', async () => {
-    const response = new BlobResponse('application/pdf')
-
-    await response.setResponse(mockResponseHandler)
-
-    expect(response.getAcceptHeader()).toBe('application/pdf')
-    expect(response.getBody()).toBeInstanceOf(Blob)
-  })
-
-  it('throws when resolveBody is called without a response', () => {
-    const response = new JsonResponse()
-
-    expect(() => (response as any).resolveBody()).toThrow('Response is not set')
-
-    const plain = new PlainTextResponse()
-    expect(() => (plain as any).resolveBody()).toThrow('Response is not set')
-
-    const blob = new BlobResponse()
-    expect(() => (blob as any).resolveBody()).toThrow('Response is not set')
-  })
-})