| |
| |
| |
| |
| |
| import { faker } from '@faker-js/faker' |
| import { HttpResponse, delay, http } from 'msw' |
| import type { RequestHandlerOptions } from 'msw' |
|
|
| import { |
| CodexAuthAttemptStatus, |
| FontSource, |
| ImageRole, |
| JobStatus, |
| LlmProviderCatalogStatus, |
| LlmStateStatus, |
| LlmTargetKind, |
| MaskRole, |
| PipelineStep, |
| TextAlign, |
| TextDirection, |
| } from '../schemas' |
| import type { |
| AddImageLayerResponse, |
| AppConfig, |
| AppEvent, |
| CodexAuthStatus, |
| CodexDeviceLogin, |
| CodexDeviceLoginStatus, |
| CodexImageGenerationResponse, |
| CreatePagesResponse, |
| DataConfig, |
| EngineCatalog, |
| FontFaceInfo, |
| FontPrediction, |
| GoogleFontCatalog, |
| HistoryResult, |
| HttpConfig, |
| ListDownloadsResponse, |
| ListOperationsResponse, |
| ListProjectsResponse, |
| LlmCatalog, |
| LlmState, |
| LlmTarget, |
| MetaInfo, |
| PipelineConfig, |
| ProjectSummary, |
| PutMaskResponse, |
| SceneSnapshot, |
| StartDownloadResponse, |
| StartPipelineResponse, |
| TextShaderEffect, |
| TextStrokeStyle, |
| TextStyle, |
| Transform, |
| } from '../schemas' |
|
|
| export const getStartCodexDeviceLoginResponseMock = ( |
| overrideResponse: Partial<Extract<CodexDeviceLogin, object>> = {}, |
| ): CodexDeviceLogin => ({ |
| intervalSeconds: faker.number.int({ min: 0 }), |
| loginId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| timeoutSeconds: faker.number.int({ min: 0 }), |
| userCode: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| verificationUrl: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ...overrideResponse, |
| }) |
|
|
| export const getGetCodexAuthStatusResponseCodexDeviceLoginStatusMock = ( |
| overrideResponse: Partial<CodexDeviceLoginStatus> = {}, |
| ): CodexDeviceLoginStatus => ({ |
| ...{ |
| accountId: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| error: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| loginId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| status: faker.helpers.arrayElement(Object.values(CodexAuthAttemptStatus)), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getGetCodexAuthStatusResponseMock = ( |
| overrideResponse: Partial<Extract<CodexAuthStatus, object>> = {}, |
| ): CodexAuthStatus => ({ |
| accountId: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| login: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| null, |
| { ...getGetCodexAuthStatusResponseCodexDeviceLoginStatusMock() }, |
| ]), |
| undefined, |
| ]), |
| signedIn: faker.datatype.boolean(), |
| ...overrideResponse, |
| }) |
|
|
| export const getStartCodexImageGenerationResponseMock = ( |
| overrideResponse: Partial<Extract<CodexImageGenerationResponse, object>> = {}, |
| ): CodexImageGenerationResponse => ({ |
| operationId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ...overrideResponse, |
| }) |
|
|
| export const getGetBlobResponseMock = (): ArrayBuffer => |
| new ArrayBuffer(faker.number.int({ min: 1, max: 64 })) |
|
|
| export const getGetConfigResponseDataConfigMock = ( |
| overrideResponse: Partial<DataConfig> = {}, |
| ): DataConfig => ({ |
| ...{ path: faker.string.alpha({ length: { min: 10, max: 20 } }) }, |
| ...overrideResponse, |
| }) |
|
|
| export const getGetConfigResponseHttpConfigMock = ( |
| overrideResponse: Partial<HttpConfig> = {}, |
| ): HttpConfig => ({ |
| ...{ |
| connect_timeout: faker.number.int({ min: 0 }), |
| max_retries: faker.number.int({ min: 0 }), |
| read_timeout: faker.number.int({ min: 0 }), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getGetConfigResponsePipelineConfigMock = ( |
| overrideResponse: Partial<PipelineConfig> = {}, |
| ): PipelineConfig => ({ |
| ...{ |
| bubble_segmenter: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| detector: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| font_detector: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| inpainter: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ocr: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| renderer: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| segmenter: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| translator: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getGetConfigResponseMock = ( |
| overrideResponse: Partial<Extract<AppConfig, object>> = {}, |
| ): AppConfig => ({ |
| data: faker.helpers.arrayElement([{ ...getGetConfigResponseDataConfigMock() }]), |
| http: faker.helpers.arrayElement([{ ...getGetConfigResponseHttpConfigMock() }]), |
| pipeline: faker.helpers.arrayElement([{ ...getGetConfigResponsePipelineConfigMock() }]), |
| providers: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| api_key: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| base_url: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| }), |
| ), |
| ...overrideResponse, |
| }) |
|
|
| export const getPatchConfigResponseDataConfigMock = ( |
| overrideResponse: Partial<DataConfig> = {}, |
| ): DataConfig => ({ |
| ...{ path: faker.string.alpha({ length: { min: 10, max: 20 } }) }, |
| ...overrideResponse, |
| }) |
|
|
| export const getPatchConfigResponseHttpConfigMock = ( |
| overrideResponse: Partial<HttpConfig> = {}, |
| ): HttpConfig => ({ |
| ...{ |
| connect_timeout: faker.number.int({ min: 0 }), |
| max_retries: faker.number.int({ min: 0 }), |
| read_timeout: faker.number.int({ min: 0 }), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getPatchConfigResponsePipelineConfigMock = ( |
| overrideResponse: Partial<PipelineConfig> = {}, |
| ): PipelineConfig => ({ |
| ...{ |
| bubble_segmenter: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| detector: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| font_detector: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| inpainter: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ocr: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| renderer: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| segmenter: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| translator: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getPatchConfigResponseMock = ( |
| overrideResponse: Partial<Extract<AppConfig, object>> = {}, |
| ): AppConfig => ({ |
| data: faker.helpers.arrayElement([{ ...getPatchConfigResponseDataConfigMock() }]), |
| http: faker.helpers.arrayElement([{ ...getPatchConfigResponseHttpConfigMock() }]), |
| pipeline: faker.helpers.arrayElement([{ ...getPatchConfigResponsePipelineConfigMock() }]), |
| providers: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| api_key: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| base_url: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| }), |
| ), |
| ...overrideResponse, |
| }) |
|
|
| export const getListDownloadsResponseMock = ( |
| overrideResponse: Partial<Extract<ListDownloadsResponse, object>> = {}, |
| ): ListDownloadsResponse => ({ |
| downloads: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| downloaded: faker.number.int({ min: 0 }), |
| filename: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| status: faker.helpers.arrayElement([ |
| { status: faker.helpers.arrayElement(['started'] as const) }, |
| { status: faker.helpers.arrayElement(['downloading'] as const) }, |
| { status: faker.helpers.arrayElement(['completed'] as const) }, |
| { |
| reason: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| status: faker.helpers.arrayElement(['failed'] as const), |
| }, |
| ]), |
| total: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]), |
| undefined, |
| ]), |
| }), |
| ), |
| ...overrideResponse, |
| }) |
|
|
| export const getStartDownloadResponseMock = ( |
| overrideResponse: Partial<Extract<StartDownloadResponse, object>> = {}, |
| ): StartDownloadResponse => ({ |
| operationId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ...overrideResponse, |
| }) |
|
|
| export const getGetEngineCatalogResponseMock = ( |
| overrideResponse: Partial<Extract<EngineCatalog, object>> = {}, |
| ): EngineCatalog => ({ |
| bubbleSegmenters: Array.from( |
| { length: faker.number.int({ min: 1, max: 10 }) }, |
| (_, i) => i + 1, |
| ).map(() => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ), |
| })), |
| detectors: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ), |
| }), |
| ), |
| fontDetectors: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ), |
| }), |
| ), |
| inpainters: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ), |
| }), |
| ), |
| ocr: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ), |
| })), |
| renderers: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ), |
| }), |
| ), |
| segmenters: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ), |
| }), |
| ), |
| translators: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ), |
| }), |
| ), |
| ...overrideResponse, |
| }) |
|
|
| export const getEventsResponseLlmTargetMock = ( |
| overrideResponse: Partial<LlmTarget> = {}, |
| ): LlmTarget => ({ |
| ...{ |
| kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)), |
| modelId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| providerId: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getEventsResponseMock = (): AppEvent => |
| faker.helpers.arrayElement([ |
| { |
| event: faker.helpers.arrayElement(['jobStarted'] as const), |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| kind: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| }, |
| { |
| ...{ |
| currentPage: faker.number.int({ min: 0 }), |
| currentStepIndex: faker.number.int({ min: 0 }), |
| jobId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| overallPercent: faker.number.int({ min: 0 }), |
| status: faker.helpers.arrayElement([ |
| { status: faker.helpers.arrayElement(['running'] as const) }, |
| { status: faker.helpers.arrayElement(['completed'] as const) }, |
| { status: faker.helpers.arrayElement(['cancelled'] as const) }, |
| { |
| reason: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| status: faker.helpers.arrayElement(['failed'] as const), |
| }, |
| ]), |
| step: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| null, |
| faker.helpers.arrayElement(Object.values(PipelineStep)), |
| ]), |
| undefined, |
| ]), |
| totalPages: faker.number.int({ min: 0 }), |
| totalSteps: faker.number.int({ min: 0 }), |
| }, |
| ...{ event: faker.helpers.arrayElement(['jobProgress'] as const) }, |
| }, |
| { |
| ...{ |
| jobId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| message: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| pageIndex: faker.number.int({ min: 0 }), |
| stepId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| totalPages: faker.number.int({ min: 0 }), |
| }, |
| ...{ event: faker.helpers.arrayElement(['jobWarning'] as const) }, |
| }, |
| { |
| ...{ |
| error: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| status: faker.helpers.arrayElement(Object.values(JobStatus)), |
| }, |
| ...{ event: faker.helpers.arrayElement(['jobFinished'] as const) }, |
| }, |
| { |
| ...{ |
| downloaded: faker.number.int({ min: 0 }), |
| filename: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| status: faker.helpers.arrayElement([ |
| { status: faker.helpers.arrayElement(['started'] as const) }, |
| { status: faker.helpers.arrayElement(['downloading'] as const) }, |
| { status: faker.helpers.arrayElement(['completed'] as const) }, |
| { |
| reason: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| status: faker.helpers.arrayElement(['failed'] as const), |
| }, |
| ]), |
| total: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]), |
| undefined, |
| ]), |
| }, |
| ...{ event: faker.helpers.arrayElement(['downloadProgress'] as const) }, |
| }, |
| { |
| event: faker.helpers.arrayElement(['llmLoading'] as const), |
| target: { |
| kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)), |
| modelId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| providerId: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| }, |
| }, |
| { |
| event: faker.helpers.arrayElement(['llmLoaded'] as const), |
| target: { |
| kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)), |
| modelId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| providerId: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| }, |
| }, |
| { |
| event: faker.helpers.arrayElement(['llmFailed'] as const), |
| target: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([null, { ...getEventsResponseLlmTargetMock() }]), |
| undefined, |
| ]), |
| }, |
| { event: faker.helpers.arrayElement(['llmUnloaded'] as const) }, |
| { |
| ...{ |
| downloads: Array.from( |
| { length: faker.number.int({ min: 1, max: 10 }) }, |
| (_, i) => i + 1, |
| ).map(() => ({ |
| downloaded: faker.number.int({ min: 0 }), |
| filename: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| status: faker.helpers.arrayElement([ |
| { status: faker.helpers.arrayElement(['started'] as const) }, |
| { status: faker.helpers.arrayElement(['downloading'] as const) }, |
| { status: faker.helpers.arrayElement(['completed'] as const) }, |
| { |
| reason: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| status: faker.helpers.arrayElement(['failed'] as const), |
| }, |
| ]), |
| total: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]), |
| undefined, |
| ]), |
| })), |
| jobs: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| error: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| faker.string.alpha({ length: { min: 10, max: 20 } }), |
| null, |
| ]), |
| undefined, |
| ]), |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| kind: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| status: faker.helpers.arrayElement(Object.values(JobStatus)), |
| }), |
| ), |
| }, |
| ...{ event: faker.helpers.arrayElement(['snapshot'] as const) }, |
| }, |
| ]) |
|
|
| export const getListFontsResponseMock = (): FontFaceInfo[] => |
| Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({ |
| cached: faker.datatype.boolean(), |
| category: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| familyName: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| postScriptName: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| source: faker.helpers.arrayElement(Object.values(FontSource)), |
| })) |
|
|
| export const getGetGoogleFontsCatalogResponseMock = ( |
| overrideResponse: Partial<Extract<GoogleFontCatalog, object>> = {}, |
| ): GoogleFontCatalog => ({ |
| fonts: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({ |
| category: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| family: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| subsets: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ), |
| variants: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| filename: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| style: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| weight: faker.number.int({ min: 0 }), |
| }), |
| ), |
| })), |
| ...overrideResponse, |
| }) |
|
|
| export const getGetGoogleFontFileResponseMock = (): ArrayBuffer => |
| new ArrayBuffer(faker.number.int({ min: 1, max: 64 })) |
|
|
| export const getApplyCommandResponseMock = ( |
| overrideResponse: Partial<Extract<HistoryResult, object>> = {}, |
| ): HistoryResult => ({ |
| epoch: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]), |
| undefined, |
| ]), |
| ...overrideResponse, |
| }) |
|
|
| export const getRedoResponseMock = ( |
| overrideResponse: Partial<Extract<HistoryResult, object>> = {}, |
| ): HistoryResult => ({ |
| epoch: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]), |
| undefined, |
| ]), |
| ...overrideResponse, |
| }) |
|
|
| export const getUndoResponseMock = ( |
| overrideResponse: Partial<Extract<HistoryResult, object>> = {}, |
| ): HistoryResult => ({ |
| epoch: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]), |
| undefined, |
| ]), |
| ...overrideResponse, |
| }) |
|
|
| export const getGetCatalogResponseMock = ( |
| overrideResponse: Partial<Extract<LlmCatalog, object>> = {}, |
| ): LlmCatalog => ({ |
| localModels: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| languages: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| target: { |
| kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)), |
| modelId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| providerId: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| }, |
| }), |
| ), |
| providers: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| baseUrl: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| error: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| hasApiKey: faker.datatype.boolean(), |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| models: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| languages: Array.from( |
| { length: faker.number.int({ min: 1, max: 10 }) }, |
| (_, i) => i + 1, |
| ).map(() => faker.string.alpha({ length: { min: 10, max: 20 } })), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| target: { |
| kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)), |
| modelId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| providerId: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| faker.string.alpha({ length: { min: 10, max: 20 } }), |
| null, |
| ]), |
| undefined, |
| ]), |
| }, |
| }), |
| ), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| requiresApiKey: faker.datatype.boolean(), |
| requiresBaseUrl: faker.datatype.boolean(), |
| status: faker.helpers.arrayElement(Object.values(LlmProviderCatalogStatus)), |
| }), |
| ), |
| ...overrideResponse, |
| }) |
|
|
| export const getGetCurrentLlmResponseLlmTargetMock = ( |
| overrideResponse: Partial<LlmTarget> = {}, |
| ): LlmTarget => ({ |
| ...{ |
| kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)), |
| modelId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| providerId: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getGetCurrentLlmResponseMock = ( |
| overrideResponse: Partial<Extract<LlmState, object>> = {}, |
| ): LlmState => ({ |
| error: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| status: faker.helpers.arrayElement(Object.values(LlmStateStatus)), |
| target: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([null, { ...getGetCurrentLlmResponseLlmTargetMock() }]), |
| undefined, |
| ]), |
| ...overrideResponse, |
| }) |
|
|
| export const getGetMetaResponseMock = ( |
| overrideResponse: Partial<Extract<MetaInfo, object>> = {}, |
| ): MetaInfo => ({ |
| mlDevice: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| version: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ...overrideResponse, |
| }) |
|
|
| export const getListOperationsResponseMock = ( |
| overrideResponse: Partial<Extract<ListOperationsResponse, object>> = {}, |
| ): ListOperationsResponse => ({ |
| operations: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| error: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| kind: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| status: faker.helpers.arrayElement(Object.values(JobStatus)), |
| }), |
| ), |
| ...overrideResponse, |
| }) |
|
|
| export const getCreatePagesResponseMock = ( |
| overrideResponse: Partial<Extract<CreatePagesResponse, object>> = {}, |
| ): CreatePagesResponse => ({ |
| pages: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => |
| faker.string.uuid(), |
| ), |
| ...overrideResponse, |
| }) |
|
|
| export const getCreatePagesFromPathsResponseMock = ( |
| overrideResponse: Partial<Extract<CreatePagesResponse, object>> = {}, |
| ): CreatePagesResponse => ({ |
| pages: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => |
| faker.string.uuid(), |
| ), |
| ...overrideResponse, |
| }) |
|
|
| export const getAddImageLayerResponseMock = ( |
| overrideResponse: Partial<Extract<AddImageLayerResponse, object>> = {}, |
| ): AddImageLayerResponse => ({ node: faker.string.uuid(), ...overrideResponse }) |
|
|
| export const getPutMaskResponseMock = ( |
| overrideResponse: Partial<Extract<PutMaskResponse, object>> = {}, |
| ): PutMaskResponse => ({ |
| blob: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| node: faker.string.uuid(), |
| ...overrideResponse, |
| }) |
|
|
| export const getGetPageThumbnailResponseMock = (): ArrayBuffer => |
| new ArrayBuffer(faker.number.int({ min: 1, max: 64 })) |
|
|
| export const getStartPipelineResponseMock = ( |
| overrideResponse: Partial<Extract<StartPipelineResponse, object>> = {}, |
| ): StartPipelineResponse => ({ |
| operationId: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ...overrideResponse, |
| }) |
|
|
| export const getListProjectsResponseMock = ( |
| overrideResponse: Partial<Extract<ListProjectsResponse, object>> = {}, |
| ): ListProjectsResponse => ({ |
| projects: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| path: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| updatedAtMs: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]), |
| }), |
| ), |
| ...overrideResponse, |
| }) |
|
|
| export const getCreateProjectResponseMock = ( |
| overrideResponse: Partial<Extract<ProjectSummary, object>> = {}, |
| ): ProjectSummary => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| path: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| updatedAtMs: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]), |
| ...overrideResponse, |
| }) |
|
|
| export const getPutCurrentProjectResponseMock = ( |
| overrideResponse: Partial<Extract<ProjectSummary, object>> = {}, |
| ): ProjectSummary => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| path: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| updatedAtMs: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]), |
| ...overrideResponse, |
| }) |
|
|
| export const getExportCurrentProjectResponseMock = (): ArrayBuffer => |
| new ArrayBuffer(faker.number.int({ min: 1, max: 64 })) |
|
|
| export const getImportProjectResponseMock = ( |
| overrideResponse: Partial<Extract<ProjectSummary, object>> = {}, |
| ): ProjectSummary => ({ |
| id: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| path: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| updatedAtMs: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]), |
| ...overrideResponse, |
| }) |
|
|
| export const getGetSceneBinResponseMock = (): ArrayBuffer => |
| new ArrayBuffer(faker.number.int({ min: 1, max: 64 })) |
|
|
| export const getGetSceneJsonResponseFontPredictionMock = ( |
| overrideResponse: Partial<FontPrediction> = {}, |
| ): FontPrediction => ({ |
| ...{ |
| angleDeg: faker.number.float({ fractionDigits: 2 }), |
| direction: faker.helpers.arrayElement(Object.values(TextDirection)), |
| fontSizePx: faker.number.float({ fractionDigits: 2 }), |
| lineHeight: faker.number.float({ fractionDigits: 2 }), |
| namedFonts: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| index: faker.number.int({ min: 0 }), |
| language: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]), |
| undefined, |
| ]), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| probability: faker.number.float({ fractionDigits: 2 }), |
| serif: faker.datatype.boolean(), |
| }), |
| ), |
| strokeColor: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.number.int({ min: 0 }), |
| ), |
| strokeWidthPx: faker.number.float({ fractionDigits: 2 }), |
| textColor: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => faker.number.int({ min: 0 }), |
| ), |
| topFonts: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map( |
| () => ({ |
| index: faker.number.int({ min: 0 }), |
| score: faker.number.float({ fractionDigits: 2 }), |
| }), |
| ), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getGetSceneJsonResponseTransformMock = ( |
| overrideResponse: Partial<Transform> = {}, |
| ): Transform => ({ |
| ...{ |
| height: faker.number.float({ fractionDigits: 2 }), |
| rotationDeg: faker.helpers.arrayElement([faker.number.float({ fractionDigits: 2 }), undefined]), |
| width: faker.number.float({ fractionDigits: 2 }), |
| x: faker.number.float({ fractionDigits: 2 }), |
| y: faker.number.float({ fractionDigits: 2 }), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getGetSceneJsonResponseTextShaderEffectMock = ( |
| overrideResponse: Partial<TextShaderEffect> = {}, |
| ): TextShaderEffect => ({ |
| ...{ |
| bold: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]), |
| italic: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getGetSceneJsonResponseTextStrokeStyleMock = ( |
| overrideResponse: Partial<TextStrokeStyle> = {}, |
| ): TextStrokeStyle => ({ |
| ...{ |
| color: faker.helpers.arrayElement([ |
| Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => |
| faker.number.int({ min: 0 }), |
| ), |
| undefined, |
| ]), |
| enabled: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]), |
| widthPx: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.number.float({ fractionDigits: 2 }), null]), |
| undefined, |
| ]), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getGetSceneJsonResponseTextStyleMock = ( |
| overrideResponse: Partial<TextStyle> = {}, |
| ): TextStyle => ({ |
| ...{ |
| color: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => |
| faker.number.int({ min: 0 }), |
| ), |
| effect: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([null, { ...getGetSceneJsonResponseTextShaderEffectMock() }]), |
| undefined, |
| ]), |
| fontFamilies: Array.from( |
| { length: faker.number.int({ min: 1, max: 10 }) }, |
| (_, i) => i + 1, |
| ).map(() => faker.string.alpha({ length: { min: 10, max: 20 } })), |
| fontSize: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.number.float({ fractionDigits: 2 }), null]), |
| undefined, |
| ]), |
| stroke: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([null, { ...getGetSceneJsonResponseTextStrokeStyleMock() }]), |
| undefined, |
| ]), |
| textAlign: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([null, faker.helpers.arrayElement(Object.values(TextAlign))]), |
| undefined, |
| ]), |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getGetSceneJsonResponseMock = ( |
| overrideResponse: Partial<Extract<SceneSnapshot, object>> = {}, |
| ): SceneSnapshot => ({ |
| epoch: faker.number.int({ min: 0 }), |
| scene: { |
| pages: { |
| [faker.string.alphanumeric(5)]: { |
| height: faker.number.int({ min: 0 }), |
| id: faker.string.uuid(), |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| nodes: { |
| [faker.string.alphanumeric(5)]: { |
| id: faker.string.uuid(), |
| kind: faker.helpers.arrayElement([ |
| { |
| image: { |
| blob: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| name: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| faker.string.alpha({ length: { min: 10, max: 20 } }), |
| null, |
| ]), |
| undefined, |
| ]), |
| naturalHeight: faker.number.int({ min: 0 }), |
| naturalWidth: faker.number.int({ min: 0 }), |
| opacity: faker.helpers.arrayElement([ |
| faker.number.float({ fractionDigits: 2 }), |
| undefined, |
| ]), |
| role: faker.helpers.arrayElement(Object.values(ImageRole)), |
| }, |
| }, |
| { |
| text: { |
| confidence: faker.helpers.arrayElement([ |
| faker.number.float({ fractionDigits: 2 }), |
| undefined, |
| ]), |
| detectedFontSizePx: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.number.float({ fractionDigits: 2 }), null]), |
| undefined, |
| ]), |
| detector: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| faker.string.alpha({ length: { min: 10, max: 20 } }), |
| null, |
| ]), |
| undefined, |
| ]), |
| fontPrediction: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| null, |
| { ...getGetSceneJsonResponseFontPredictionMock() }, |
| ]), |
| undefined, |
| ]), |
| linePolygons: faker.helpers.arrayElement([ |
| Array.from( |
| { length: faker.number.int({ min: 1, max: 10 }) }, |
| (_, i) => i + 1, |
| ).map(() => |
| Array.from( |
| { length: faker.number.int({ min: 1, max: 10 }) }, |
| (_, i) => i + 1, |
| ).map(() => |
| Array.from( |
| { length: faker.number.int({ min: 1, max: 10 }) }, |
| (_, i) => i + 1, |
| ).map(() => faker.number.float({ fractionDigits: 2 })), |
| ), |
| ), |
| undefined, |
| ]), |
| lockLayoutBox: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]), |
| renderedDirection: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| null, |
| faker.helpers.arrayElement(Object.values(TextDirection)), |
| ]), |
| undefined, |
| ]), |
| rotationDeg: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([faker.number.float({ fractionDigits: 2 }), null]), |
| undefined, |
| ]), |
| sourceDirection: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| null, |
| faker.helpers.arrayElement(Object.values(TextDirection)), |
| ]), |
| undefined, |
| ]), |
| sourceLang: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| faker.string.alpha({ length: { min: 10, max: 20 } }), |
| null, |
| ]), |
| undefined, |
| ]), |
| sprite: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| null, |
| faker.string.alpha({ length: { min: 10, max: 20 } }), |
| ]), |
| undefined, |
| ]), |
| spriteTransform: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| null, |
| { ...getGetSceneJsonResponseTransformMock() }, |
| ]), |
| undefined, |
| ]), |
| style: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| null, |
| { ...getGetSceneJsonResponseTextStyleMock() }, |
| ]), |
| undefined, |
| ]), |
| text: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| faker.string.alpha({ length: { min: 10, max: 20 } }), |
| null, |
| ]), |
| undefined, |
| ]), |
| translation: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| faker.string.alpha({ length: { min: 10, max: 20 } }), |
| null, |
| ]), |
| undefined, |
| ]), |
| }, |
| }, |
| { |
| mask: { |
| blob: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| role: faker.helpers.arrayElement(Object.values(MaskRole)), |
| }, |
| }, |
| ]), |
| transform: faker.helpers.arrayElement([ |
| { |
| height: faker.number.float({ fractionDigits: 2 }), |
| rotationDeg: faker.helpers.arrayElement([ |
| faker.number.float({ fractionDigits: 2 }), |
| undefined, |
| ]), |
| width: faker.number.float({ fractionDigits: 2 }), |
| x: faker.number.float({ fractionDigits: 2 }), |
| y: faker.number.float({ fractionDigits: 2 }), |
| }, |
| undefined, |
| ]), |
| visible: faker.datatype.boolean(), |
| }, |
| }, |
| width: faker.number.int({ min: 0 }), |
| }, |
| }, |
| project: { |
| createdAt: faker.date.past().toISOString().slice(0, 19) + 'Z', |
| name: faker.string.alpha({ length: { min: 10, max: 20 } }), |
| style: faker.helpers.arrayElement([ |
| { |
| defaultFont: faker.helpers.arrayElement([ |
| faker.helpers.arrayElement([ |
| faker.string.alpha({ length: { min: 10, max: 20 } }), |
| null, |
| ]), |
| undefined, |
| ]), |
| }, |
| undefined, |
| ]), |
| updatedAt: faker.date.past().toISOString().slice(0, 19) + 'Z', |
| }, |
| }, |
| ...overrideResponse, |
| }) |
|
|
| export const getStartCodexDeviceLoginMockHandler = ( |
| overrideResponse?: |
| | CodexDeviceLogin |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<CodexDeviceLogin> | CodexDeviceLogin), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/ai/codex/auth/device-code', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getStartCodexDeviceLoginResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getDeleteCodexSessionMockHandler = ( |
| overrideResponse?: |
| | void |
| | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<void> | void), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.delete( |
| '*/ai/codex/auth/session', |
| async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => { |
| await delay(0) |
| if (typeof overrideResponse === 'function') { |
| await overrideResponse(info) |
| } |
|
|
| return new HttpResponse(null, { status: 204 }) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetCodexAuthStatusMockHandler = ( |
| overrideResponse?: |
| | CodexAuthStatus |
| | (( |
| info: Parameters<Parameters<typeof http.get>[1]>[0], |
| ) => Promise<CodexAuthStatus> | CodexAuthStatus), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/ai/codex/auth/status', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetCodexAuthStatusResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getStartCodexImageGenerationMockHandler = ( |
| overrideResponse?: |
| | CodexImageGenerationResponse |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<CodexImageGenerationResponse> | CodexImageGenerationResponse), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/ai/codex/images', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getStartCodexImageGenerationResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetBlobMockHandler = ( |
| overrideResponse?: |
| | ArrayBuffer |
| | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<ArrayBuffer> | ArrayBuffer), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/blobs/:hash', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| const binaryBody = |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetBlobResponseMock() |
| return HttpResponse.arrayBuffer( |
| binaryBody instanceof ArrayBuffer ? binaryBody : new ArrayBuffer(0), |
| { status: 200, headers: { 'Content-Type': 'application/octet-stream' } }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetConfigMockHandler = ( |
| overrideResponse?: |
| | AppConfig |
| | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<AppConfig> | AppConfig), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/config', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetConfigResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getPatchConfigMockHandler = ( |
| overrideResponse?: |
| | AppConfig |
| | ((info: Parameters<Parameters<typeof http.patch>[1]>[0]) => Promise<AppConfig> | AppConfig), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.patch( |
| '*/config', |
| async (info: Parameters<Parameters<typeof http.patch>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getPatchConfigResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getSetProviderSecretMockHandler = ( |
| overrideResponse?: |
| | void |
| | ((info: Parameters<Parameters<typeof http.put>[1]>[0]) => Promise<void> | void), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.put( |
| '*/config/providers/:id/secret', |
| async (info: Parameters<Parameters<typeof http.put>[1]>[0]) => { |
| await delay(0) |
| if (typeof overrideResponse === 'function') { |
| await overrideResponse(info) |
| } |
|
|
| return new HttpResponse(null, { status: 204 }) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getClearProviderSecretMockHandler = ( |
| overrideResponse?: |
| | void |
| | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<void> | void), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.delete( |
| '*/config/providers/:id/secret', |
| async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => { |
| await delay(0) |
| if (typeof overrideResponse === 'function') { |
| await overrideResponse(info) |
| } |
|
|
| return new HttpResponse(null, { status: 204 }) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getListDownloadsMockHandler = ( |
| overrideResponse?: |
| | ListDownloadsResponse |
| | (( |
| info: Parameters<Parameters<typeof http.get>[1]>[0], |
| ) => Promise<ListDownloadsResponse> | ListDownloadsResponse), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/downloads', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getListDownloadsResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getStartDownloadMockHandler = ( |
| overrideResponse?: |
| | StartDownloadResponse |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<StartDownloadResponse> | StartDownloadResponse), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/downloads', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getStartDownloadResponseMock(), |
| { status: 202 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetEngineCatalogMockHandler = ( |
| overrideResponse?: |
| | EngineCatalog |
| | (( |
| info: Parameters<Parameters<typeof http.get>[1]>[0], |
| ) => Promise<EngineCatalog> | EngineCatalog), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/engines', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetEngineCatalogResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getEventsMockHandler = ( |
| overrideResponse?: |
| | AppEvent |
| | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<AppEvent> | AppEvent), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/events', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getEventsResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getListFontsMockHandler = ( |
| overrideResponse?: |
| | FontFaceInfo[] |
| | (( |
| info: Parameters<Parameters<typeof http.get>[1]>[0], |
| ) => Promise<FontFaceInfo[]> | FontFaceInfo[]), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/fonts', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getListFontsResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetGoogleFontsCatalogMockHandler = ( |
| overrideResponse?: |
| | GoogleFontCatalog |
| | (( |
| info: Parameters<Parameters<typeof http.get>[1]>[0], |
| ) => Promise<GoogleFontCatalog> | GoogleFontCatalog), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/google-fonts', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetGoogleFontsCatalogResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getFetchGoogleFontMockHandler = ( |
| overrideResponse?: |
| | void |
| | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Promise<void> | void), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/google-fonts/:family/fetch', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
| if (typeof overrideResponse === 'function') { |
| await overrideResponse(info) |
| } |
|
|
| return new HttpResponse(null, { status: 204 }) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetGoogleFontFileMockHandler = ( |
| overrideResponse?: |
| | ArrayBuffer |
| | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<ArrayBuffer> | ArrayBuffer), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/google-fonts/:family/:file', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| const binaryBody = |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetGoogleFontFileResponseMock() |
| return HttpResponse.arrayBuffer( |
| binaryBody instanceof ArrayBuffer ? binaryBody : new ArrayBuffer(0), |
| { status: 200, headers: { 'Content-Type': 'font/ttf' } }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getApplyCommandMockHandler = ( |
| overrideResponse?: |
| | HistoryResult |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<HistoryResult> | HistoryResult), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/history/apply', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getApplyCommandResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getRedoMockHandler = ( |
| overrideResponse?: |
| | HistoryResult |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<HistoryResult> | HistoryResult), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/history/redo', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getRedoResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getUndoMockHandler = ( |
| overrideResponse?: |
| | HistoryResult |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<HistoryResult> | HistoryResult), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/history/undo', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getUndoResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetCatalogMockHandler = ( |
| overrideResponse?: |
| | LlmCatalog |
| | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<LlmCatalog> | LlmCatalog), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/llm/catalog', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetCatalogResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetCurrentLlmMockHandler = ( |
| overrideResponse?: |
| | LlmState |
| | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<LlmState> | LlmState), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/llm/current', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetCurrentLlmResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getPutCurrentLlmMockHandler = ( |
| overrideResponse?: |
| | void |
| | ((info: Parameters<Parameters<typeof http.put>[1]>[0]) => Promise<void> | void), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.put( |
| '*/llm/current', |
| async (info: Parameters<Parameters<typeof http.put>[1]>[0]) => { |
| await delay(0) |
| if (typeof overrideResponse === 'function') { |
| await overrideResponse(info) |
| } |
|
|
| return new HttpResponse(null, { status: 204 }) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getDeleteCurrentLlmMockHandler = ( |
| overrideResponse?: |
| | void |
| | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<void> | void), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.delete( |
| '*/llm/current', |
| async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => { |
| await delay(0) |
| if (typeof overrideResponse === 'function') { |
| await overrideResponse(info) |
| } |
|
|
| return new HttpResponse(null, { status: 204 }) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetMetaMockHandler = ( |
| overrideResponse?: |
| | MetaInfo |
| | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<MetaInfo> | MetaInfo), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/meta', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetMetaResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getListOperationsMockHandler = ( |
| overrideResponse?: |
| | ListOperationsResponse |
| | (( |
| info: Parameters<Parameters<typeof http.get>[1]>[0], |
| ) => Promise<ListOperationsResponse> | ListOperationsResponse), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/operations', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getListOperationsResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getCancelOperationMockHandler = ( |
| overrideResponse?: |
| | void |
| | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<void> | void), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.delete( |
| '*/operations/:id', |
| async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => { |
| await delay(0) |
| if (typeof overrideResponse === 'function') { |
| await overrideResponse(info) |
| } |
|
|
| return new HttpResponse(null, { status: 204 }) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getCreatePagesMockHandler = ( |
| overrideResponse?: |
| | CreatePagesResponse |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<CreatePagesResponse> | CreatePagesResponse), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/pages', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getCreatePagesResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getCreatePagesFromPathsMockHandler = ( |
| overrideResponse?: |
| | CreatePagesResponse |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<CreatePagesResponse> | CreatePagesResponse), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/pages/from-paths', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getCreatePagesFromPathsResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getAddImageLayerMockHandler = ( |
| overrideResponse?: |
| | AddImageLayerResponse |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<AddImageLayerResponse> | AddImageLayerResponse), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/pages/:id/image-layers', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getAddImageLayerResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getPutMaskMockHandler = ( |
| overrideResponse?: |
| | PutMaskResponse |
| | (( |
| info: Parameters<Parameters<typeof http.put>[1]>[0], |
| ) => Promise<PutMaskResponse> | PutMaskResponse), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.put( |
| '*/pages/:id/masks/:role', |
| async (info: Parameters<Parameters<typeof http.put>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getPutMaskResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetPageThumbnailMockHandler = ( |
| overrideResponse?: |
| | ArrayBuffer |
| | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<ArrayBuffer> | ArrayBuffer), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/pages/:id/thumbnail', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| const binaryBody = |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetPageThumbnailResponseMock() |
| return HttpResponse.arrayBuffer( |
| binaryBody instanceof ArrayBuffer ? binaryBody : new ArrayBuffer(0), |
| { status: 200, headers: { 'Content-Type': 'image/webp' } }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getStartPipelineMockHandler = ( |
| overrideResponse?: |
| | StartPipelineResponse |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<StartPipelineResponse> | StartPipelineResponse), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/pipelines', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getStartPipelineResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getListProjectsMockHandler = ( |
| overrideResponse?: |
| | ListProjectsResponse |
| | (( |
| info: Parameters<Parameters<typeof http.get>[1]>[0], |
| ) => Promise<ListProjectsResponse> | ListProjectsResponse), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/projects', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getListProjectsResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getCreateProjectMockHandler = ( |
| overrideResponse?: |
| | ProjectSummary |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<ProjectSummary> | ProjectSummary), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/projects', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getCreateProjectResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getPutCurrentProjectMockHandler = ( |
| overrideResponse?: |
| | ProjectSummary |
| | (( |
| info: Parameters<Parameters<typeof http.put>[1]>[0], |
| ) => Promise<ProjectSummary> | ProjectSummary), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.put( |
| '*/projects/current', |
| async (info: Parameters<Parameters<typeof http.put>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getPutCurrentProjectResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getDeleteCurrentProjectMockHandler = ( |
| overrideResponse?: |
| | void |
| | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<void> | void), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.delete( |
| '*/projects/current', |
| async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => { |
| await delay(0) |
| if (typeof overrideResponse === 'function') { |
| await overrideResponse(info) |
| } |
|
|
| return new HttpResponse(null, { status: 204 }) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getExportCurrentProjectMockHandler = ( |
| overrideResponse?: |
| | ArrayBuffer |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<ArrayBuffer> | ArrayBuffer), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/projects/current/export', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| const binaryBody = |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getExportCurrentProjectResponseMock() |
| return HttpResponse.arrayBuffer( |
| binaryBody instanceof ArrayBuffer ? binaryBody : new ArrayBuffer(0), |
| { status: 200, headers: { 'Content-Type': 'application/octet-stream' } }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getImportProjectMockHandler = ( |
| overrideResponse?: |
| | ProjectSummary |
| | (( |
| info: Parameters<Parameters<typeof http.post>[1]>[0], |
| ) => Promise<ProjectSummary> | ProjectSummary), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.post( |
| '*/projects/import', |
| async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getImportProjectResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetSceneBinMockHandler = ( |
| overrideResponse?: |
| | ArrayBuffer |
| | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<ArrayBuffer> | ArrayBuffer), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/scene.bin', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| const binaryBody = |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetSceneBinResponseMock() |
| return HttpResponse.arrayBuffer( |
| binaryBody instanceof ArrayBuffer ? binaryBody : new ArrayBuffer(0), |
| { status: 200, headers: { 'Content-Type': 'application/octet-stream' } }, |
| ) |
| }, |
| options, |
| ) |
| } |
|
|
| export const getGetSceneJsonMockHandler = ( |
| overrideResponse?: |
| | SceneSnapshot |
| | (( |
| info: Parameters<Parameters<typeof http.get>[1]>[0], |
| ) => Promise<SceneSnapshot> | SceneSnapshot), |
| options?: RequestHandlerOptions, |
| ) => { |
| return http.get( |
| '*/scene.json', |
| async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => { |
| await delay(0) |
|
|
| return HttpResponse.json( |
| overrideResponse !== undefined |
| ? typeof overrideResponse === 'function' |
| ? await overrideResponse(info) |
| : overrideResponse |
| : getGetSceneJsonResponseMock(), |
| { status: 200 }, |
| ) |
| }, |
| options, |
| ) |
| } |
| export const getDefaultMock = () => [ |
| getStartCodexDeviceLoginMockHandler(), |
| getDeleteCodexSessionMockHandler(), |
| getGetCodexAuthStatusMockHandler(), |
| getStartCodexImageGenerationMockHandler(), |
| getGetBlobMockHandler(), |
| getGetConfigMockHandler(), |
| getPatchConfigMockHandler(), |
| getSetProviderSecretMockHandler(), |
| getClearProviderSecretMockHandler(), |
| getListDownloadsMockHandler(), |
| getStartDownloadMockHandler(), |
| getGetEngineCatalogMockHandler(), |
| getEventsMockHandler(), |
| getListFontsMockHandler(), |
| getGetGoogleFontsCatalogMockHandler(), |
| getFetchGoogleFontMockHandler(), |
| getGetGoogleFontFileMockHandler(), |
| getApplyCommandMockHandler(), |
| getRedoMockHandler(), |
| getUndoMockHandler(), |
| getGetCatalogMockHandler(), |
| getGetCurrentLlmMockHandler(), |
| getPutCurrentLlmMockHandler(), |
| getDeleteCurrentLlmMockHandler(), |
| getGetMetaMockHandler(), |
| getListOperationsMockHandler(), |
| getCancelOperationMockHandler(), |
| getCreatePagesMockHandler(), |
| getCreatePagesFromPathsMockHandler(), |
| getAddImageLayerMockHandler(), |
| getPutMaskMockHandler(), |
| getGetPageThumbnailMockHandler(), |
| getStartPipelineMockHandler(), |
| getListProjectsMockHandler(), |
| getCreateProjectMockHandler(), |
| getPutCurrentProjectMockHandler(), |
| getDeleteCurrentProjectMockHandler(), |
| getExportCurrentProjectMockHandler(), |
| getImportProjectMockHandler(), |
| getGetSceneBinMockHandler(), |
| getGetSceneJsonMockHandler(), |
| ] |
|
|
