Merge branch 'feature/frontend-uploader' of https://github.com/monicasmith463/study-assistant into feature/frontend-uploader

Author: monicasmith463

frontend/src/client/core/ApiError.ts

@@ -1,25 +1,25 @@
-import type { ApiRequestOptions } from "./ApiRequestOptions";
-import type { ApiResult } from "./ApiResult";
+import type { ApiRequestOptions } from "./ApiRequestOptions"
+import type { ApiResult } from "./ApiResult"
 
 export class ApiError extends Error {
-  public readonly url: string;
-  public readonly status: number;
-  public readonly statusText: string;
-  public readonly body: unknown;
-  public readonly request: ApiRequestOptions;
+  public readonly url: string
+  public readonly status: number
+  public readonly statusText: string
+  public readonly body: unknown
+  public readonly request: ApiRequestOptions
 
   constructor(
     request: ApiRequestOptions,
     response: ApiResult,
     message: string,
   ) {
-    super(message);
+    super(message)
 
-    this.name = "ApiError";
-    this.url = response.url;
-    this.status = response.status;
-    this.statusText = response.statusText;
-    this.body = response.body;
-    this.request = request;
+    this.name = "ApiError"
+    this.url = response.url
+    this.status = response.status
+    this.statusText = response.statusText
+    this.body = response.body
+    this.request = request
   }
 }

frontend/src/client/core/ApiRequestOptions.ts

@@ -1,21 +1,21 @@
 export type ApiRequestOptions<T = unknown> = {
-  readonly body?: any;
-  readonly cookies?: Record<string, unknown>;
-  readonly errors?: Record<number | string, string>;
-  readonly formData?: Record<string, unknown> | any[] | Blob | File;
-  readonly headers?: Record<string, unknown>;
-  readonly mediaType?: string;
+  readonly body?: any
+  readonly cookies?: Record<string, unknown>
+  readonly errors?: Record<number | string, string>
+  readonly formData?: Record<string, unknown> | any[] | Blob | File
+  readonly headers?: Record<string, unknown>
+  readonly mediaType?: string
   readonly method:
     | "DELETE"
     | "GET"
     | "HEAD"
     | "OPTIONS"
     | "PATCH"
     | "POST"
-    | "PUT";
-  readonly path?: Record<string, unknown>;
-  readonly query?: Record<string, unknown>;
-  readonly responseHeader?: string;
-  readonly responseTransformer?: (data: unknown) => Promise<T>;
-  readonly url: string;
-};
+    | "PUT"
+  readonly path?: Record<string, unknown>
+  readonly query?: Record<string, unknown>
+  readonly responseHeader?: string
+  readonly responseTransformer?: (data: unknown) => Promise<T>
+  readonly url: string
+}

frontend/src/client/core/ApiResult.ts

@@ -1,7 +1,7 @@
 export type ApiResult<TData = any> = {
-  readonly body: TData;
-  readonly ok: boolean;
-  readonly status: number;
-  readonly statusText: string;
-  readonly url: string;
-};
+  readonly body: TData
+  readonly ok: boolean
+  readonly status: number
+  readonly statusText: string
+  readonly url: string
+}

frontend/src/client/core/CancelablePromise.ts

@@ -1,30 +1,30 @@
 export class CancelError extends Error {
   constructor(message: string) {
-    super(message);
-    this.name = "CancelError";
+    super(message)
+    this.name = "CancelError"
   }
 
   public get isCancelled(): boolean {
-    return true;
+    return true
   }
 }
 
 export interface OnCancel {
-  readonly isResolved: boolean;
-  readonly isRejected: boolean;
-  readonly isCancelled: boolean;
+  readonly isResolved: boolean
+  readonly isRejected: boolean
+  readonly isCancelled: boolean
 
-  (cancelHandler: () => void): void;
+  (cancelHandler: () => void): void
 }
 
 export class CancelablePromise<T> implements Promise<T> {
-  private _isResolved: boolean;
-  private _isRejected: boolean;
-  private _isCancelled: boolean;
-  readonly cancelHandlers: (() => void)[];
-  readonly promise: Promise<T>;
-  private _resolve?: (value: T | PromiseLike<T>) => void;
-  private _reject?: (reason?: unknown) => void;
+  private _isResolved: boolean
+  private _isRejected: boolean
+  private _isCancelled: boolean
+  readonly cancelHandlers: (() => void)[]
+  readonly promise: Promise<T>
+  private _resolve?: (value: T | PromiseLike<T>) => void
+  private _reject?: (reason?: unknown) => void
 
   constructor(
     executor: (
@@ -33,94 +33,94 @@ export class CancelablePromise<T> implements Promise<T> {
       onCancel: OnCancel,
     ) => void,
   ) {
-    this._isResolved = false;
-    this._isRejected = false;
-    this._isCancelled = false;
-    this.cancelHandlers = [];
+    this._isResolved = false
+    this._isRejected = false
+    this._isCancelled = false
+    this.cancelHandlers = []
     this.promise = new Promise<T>((resolve, reject) => {
-      this._resolve = resolve;
-      this._reject = reject;
+      this._resolve = resolve
+      this._reject = reject
 
       const onResolve = (value: T | PromiseLike<T>): void => {
         if (this._isResolved || this._isRejected || this._isCancelled) {
-          return;
+          return
         }
-        this._isResolved = true;
-        if (this._resolve) this._resolve(value);
-      };
+        this._isResolved = true
+        if (this._resolve) this._resolve(value)
+      }
 
       const onReject = (reason?: unknown): void => {
         if (this._isResolved || this._isRejected || this._isCancelled) {
-          return;
+          return
         }
-        this._isRejected = true;
-        if (this._reject) this._reject(reason);
-      };
+        this._isRejected = true
+        if (this._reject) this._reject(reason)
+      }
 
       const onCancel = (cancelHandler: () => void): void => {
         if (this._isResolved || this._isRejected || this._isCancelled) {
-          return;
+          return
         }
-        this.cancelHandlers.push(cancelHandler);
-      };
+        this.cancelHandlers.push(cancelHandler)
+      }
 
       Object.defineProperty(onCancel, "isResolved", {
         get: (): boolean => this._isResolved,
-      });
+      })
 
       Object.defineProperty(onCancel, "isRejected", {
         get: (): boolean => this._isRejected,
-      });
+      })
 
       Object.defineProperty(onCancel, "isCancelled", {
         get: (): boolean => this._isCancelled,
-      });
+      })
 
-      return executor(onResolve, onReject, onCancel as OnCancel);
-    });
+      return executor(onResolve, onReject, onCancel as OnCancel)
+    })
   }
 
   get [Symbol.toStringTag]() {
-    return "Cancellable Promise";
+    return "Cancellable Promise"
   }
 
   public then<TResult1 = T, TResult2 = never>(
     onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
     onRejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
   ): Promise<TResult1 | TResult2> {
-    return this.promise.then(onFulfilled, onRejected);
+    return this.promise.then(onFulfilled, onRejected)
   }
 
   public catch<TResult = never>(
     onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null,
   ): Promise<T | TResult> {
-    return this.promise.catch(onRejected);
+    return this.promise.catch(onRejected)
   }
 
   public finally(onFinally?: (() => void) | null): Promise<T> {
-    return this.promise.finally(onFinally);
+    return this.promise.finally(onFinally)
   }
 
   public cancel(): void {
     if (this._isResolved || this._isRejected || this._isCancelled) {
-      return;
+      return
     }
-    this._isCancelled = true;
+    this._isCancelled = true
     if (this.cancelHandlers.length) {
       try {
         for (const cancelHandler of this.cancelHandlers) {
-          cancelHandler();
+          cancelHandler()
         }
       } catch (error) {
-        console.warn("Cancellation threw an error", error);
-        return;
+        console.warn("Cancellation threw an error", error)
+        return
       }
     }
-    this.cancelHandlers.length = 0;
-    if (this._reject) this._reject(new CancelError("Request aborted"));
+    this.cancelHandlers.length = 0
+    if (this._reject) this._reject(new CancelError("Request aborted"))
   }
 
   public get isCancelled(): boolean {
-    return this._isCancelled;
+    return this._isCancelled
   }
 }

frontend/src/client/core/OpenAPI.ts

@@ -1,44 +1,44 @@
-import type { AxiosRequestConfig, AxiosResponse } from "axios";
-import type { ApiRequestOptions } from "./ApiRequestOptions";
+import type { AxiosRequestConfig, AxiosResponse } from "axios"
+import type { ApiRequestOptions } from "./ApiRequestOptions"
 
-type Headers = Record<string, string>;
-type Middleware<T> = (value: T) => T | Promise<T>;
-type Resolver<T> = (options: ApiRequestOptions<T>) => Promise<T>;
+type Headers = Record<string, string>
+type Middleware<T> = (value: T) => T | Promise<T>
+type Resolver<T> = (options: ApiRequestOptions<T>) => Promise<T>
 
 export class Interceptors<T> {
-  _fns: Middleware<T>[];
+  _fns: Middleware<T>[]
 
   constructor() {
-    this._fns = [];
+    this._fns = []
   }
 
   eject(fn: Middleware<T>): void {
-    const index = this._fns.indexOf(fn);
+    const index = this._fns.indexOf(fn)
     if (index !== -1) {
-      this._fns = [...this._fns.slice(0, index), ...this._fns.slice(index + 1)];
+      this._fns = [...this._fns.slice(0, index), ...this._fns.slice(index + 1)]
     }
   }
 
   use(fn: Middleware<T>): void {
-    this._fns = [...this._fns, fn];
+    this._fns = [...this._fns, fn]
   }
 }
 
 export type OpenAPIConfig = {
-  BASE: string;
-  CREDENTIALS: "include" | "omit" | "same-origin";
-  ENCODE_PATH?: ((path: string) => string) | undefined;
-  HEADERS?: Headers | Resolver<Headers> | undefined;
-  PASSWORD?: string | Resolver<string> | undefined;
-  TOKEN?: string | Resolver<string> | undefined;
-  USERNAME?: string | Resolver<string> | undefined;
-  VERSION: string;
-  WITH_CREDENTIALS: boolean;
+  BASE: string
+  CREDENTIALS: "include" | "omit" | "same-origin"
+  ENCODE_PATH?: ((path: string) => string) | undefined
+  HEADERS?: Headers | Resolver<Headers> | undefined
+  PASSWORD?: string | Resolver<string> | undefined
+  TOKEN?: string | Resolver<string> | undefined
+  USERNAME?: string | Resolver<string> | undefined
+  VERSION: string
+  WITH_CREDENTIALS: boolean
   interceptors: {
-    request: Interceptors<AxiosRequestConfig>;
-    response: Interceptors<AxiosResponse>;
-  };
-};
+    request: Interceptors<AxiosRequestConfig>
+    response: Interceptors<AxiosResponse>
+  }
+}
 
 export const OpenAPI: OpenAPIConfig = {
   BASE: "",
@@ -54,4 +54,4 @@ export const OpenAPI: OpenAPIConfig = {
     request: new Interceptors(),
     response: new Interceptors(),
   },
-};
+}