@opra/angular 1.20.0 → 1.22.0

package/src/angular-backend.ts

@@ -1,246 +0,0 @@
-// @ts-ignore
-import { HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';
-// @ts-ignore
-import * as Angular from '@angular/common/http';
-import typeIs from '@browsery/type-is';
-import {
-  HttpBackend,
-  type HttpDownloadProgressEvent,
-  type HttpEvent,
-  HttpEventType,
-  HttpResponse,
-  type HttpResponseEvent,
-  type HttpResponseHeaderEvent,
-  type HttpSentEvent,
-  type HttpUploadProgressEvent,
-} from '@opra/client';
-import { isBlob } from '@opra/common';
-import { Observable } from 'rxjs';
-import { isReadableStreamLike } from 'rxjs/internal/util/isReadableStreamLike';
-import type { StrictOmit } from 'ts-gems';
-
-/**
- *
- * @class AngularBackend
- */
-export class AngularBackend extends HttpBackend {
-  defaults: AngularBackend.RequestDefaults;
-
-  constructor(
-    readonly httpClient: Angular.HttpClient,
-    serviceUrl: string,
-    options?: AngularBackend.Options,
-  ) {
-    super(serviceUrl, options);
-    this.defaults = {
-      ...options?.defaults,
-      headers:
-        options?.defaults?.headers instanceof Headers
-          ? options?.defaults?.headers
-          : new Headers(options?.defaults?.headers),
-      params:
-        options?.defaults?.params instanceof URLSearchParams
-          ? options?.defaults?.params
-          : new URLSearchParams(options?.defaults?.params),
-    };
-  }
-
-  handle(init: AngularBackend.RequestInit): Observable<HttpEvent> {
-    const requestInit = this.prepareRequest(init);
-    const request = new Angular.HttpRequest(
-      requestInit.method,
-      requestInit.url.toString(),
-      {
-        ...requestInit,
-        headers: new HttpHeaders(requestInit.headers),
-      },
-    );
-
-    const _this = this;
-    return new Observable<HttpEvent>(subscriber => {
-      // Send request
-      this.send(request).subscribe({
-        next(event) {
-          if (event.type === Angular.HttpEventType.Sent) {
-            // Emit 'Sent' event
-            subscriber.next({
-              type: HttpEventType.Sent,
-              request,
-            } satisfies HttpSentEvent);
-            return;
-          }
-
-          if (event.type === Angular.HttpEventType.ResponseHeader) {
-            // Emit 'ResponseHeader' event
-            const headersResponse = _this.createResponse({
-              url: request.url,
-              headers: requestInit.headers,
-              status: event.status,
-              statusText: event.statusText,
-              hasBody:
-                event.headers.has('Content-Type') ||
-                event.headers.has('Content-Length'),
-            }) as HttpResponse<never>;
-            subscriber.next({
-              request,
-              type: HttpEventType.ResponseHeader,
-              response: headersResponse,
-            } satisfies HttpResponseHeaderEvent);
-            return;
-          }
-
-          if (event.type === Angular.HttpEventType.DownloadProgress) {
-            // Emit 'DownloadProgress' event
-            subscriber.next({
-              request,
-              type: HttpEventType.DownloadProgress,
-              loaded: event.loaded,
-              total: event.total,
-            } satisfies HttpDownloadProgressEvent);
-          }
-
-          if (event.type === Angular.HttpEventType.UploadProgress) {
-            // Emit 'UploadProgress' event
-            subscriber.next({
-              request,
-              type: HttpEventType.UploadProgress,
-              loaded: event.loaded,
-              total: event.total,
-            } satisfies HttpUploadProgressEvent);
-          }
-
-          if (event.type === Angular.HttpEventType.Response) {
-            const headers = new Headers();
-            event.headers
-              .keys()
-              .forEach(k => headers.set(k, event.headers.get(k) || ''));
-            const response = _this.createResponse({
-              url: request.url,
-              headers,
-              status: event.status,
-              statusText: event.statusText,
-              hasBody: !!event.body,
-              body: event.body,
-            });
-            // Emit 'Response' event
-            subscriber.next({
-              type: HttpEventType.Response,
-              request,
-              response,
-            } satisfies HttpResponseEvent);
-          }
-        },
-        error(error) {
-          subscriber.error(error);
-        },
-        complete() {
-          subscriber.complete();
-        },
-      });
-    });
-  }
-
-  protected send(request: Angular.HttpRequest<any>) {
-    return this.httpClient.request(request);
-  }
-
-  protected prepareRequest(
-    init: AngularBackend.RequestInit,
-  ): AngularBackend.RequestInit {
-    const headers = init.headers || new Headers();
-    const requestInit: AngularBackend.RequestInit = {
-      ...init,
-      headers,
-    };
-    this.defaults.headers.forEach((val, key) => {
-      if (!headers.has(key)) headers.set(key, val);
-    });
-    const url = new URL(requestInit.url, this.serviceUrl);
-    if (this.defaults.params.size) {
-      this.defaults.params.forEach((val, key) => {
-        if (!url.searchParams.has(key)) url.searchParams.set(key, val);
-      });
-      requestInit.url = url.toString();
-    }
-    if (requestInit.body) {
-      let body: any;
-      let contentType: string;
-      if (
-        typeof requestInit.body === 'string' ||
-        typeof requestInit.body === 'number' ||
-        typeof requestInit.body === 'boolean'
-      ) {
-        contentType = 'text/plain; charset=UTF-8"';
-        body = String(requestInit.body);
-        headers.delete('Content-Size');
-      } else if (isReadableStreamLike(requestInit.body)) {
-        contentType = 'application/octet-stream';
-        body = requestInit.body;
-      } else if (Buffer.isBuffer(requestInit.body)) {
-        contentType = 'application/octet-stream';
-        body = requestInit.body;
-        headers.set('Content-Size', String(requestInit.body.length));
-      } else if (isBlob(requestInit.body)) {
-        contentType = requestInit.body.type || 'application/octet-stream';
-        body = requestInit.body;
-        headers.set('Content-Size', String(requestInit.body.size));
-      } else {
-        contentType = 'application/json';
-        body = JSON.stringify(requestInit.body);
-        headers.delete('Content-Size');
-      }
-      if (!headers.has('Content-Type') && contentType)
-        headers.set('Content-Type', contentType);
-      requestInit.body = body;
-    }
-    return requestInit;
-  }
-
-  protected createResponse(init: HttpResponse.Initiator): HttpResponse {
-    return new HttpResponse(init);
-  }
-
-  protected async parseBody(fetchResponse: Response): Promise<any> {
-    let body: any;
-    const contentType = fetchResponse.headers.get('Content-Type') || '';
-    if (typeIs.is(contentType, ['json', 'application/*+json'])) {
-      body = await fetchResponse.json();
-      if (typeof body === 'string') body = JSON.parse(body);
-    } else if (typeIs.is(contentType, ['text']))
-      body = await fetchResponse.text();
-    else if (typeIs.is(contentType, ['multipart']))
-      body = await fetchResponse.formData();
-    else {
-      const buf = await fetchResponse.arrayBuffer();
-      if (buf.byteLength) body = buf;
-    }
-    return body;
-  }
-}
-
-/**
- * @namespace AngularBackend
- */
-export namespace AngularBackend {
-  export interface Options extends HttpBackend.Options {
-    defaults?: RequestDefaults;
-  }
-
-  export interface RequestInit extends HttpBackend.RequestInit {
-    context?: HttpContext;
-    reportProgress?: boolean;
-    params?: HttpParams;
-    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
-    withCredentials?: boolean;
-  }
-
-  export interface RequestOptions extends Pick<
-    RequestInit,
-    'context' | 'reportProgress' | 'withCredentials'
-  > {}
-
-  export type RequestDefaults = StrictOmit<RequestOptions, 'context'> & {
-    headers: Headers;
-    params: URLSearchParams;
-  };
-}

package/src/angular-client.ts

@@ -1,24 +0,0 @@
-// @ts-ignore
-import { HttpClient } from '@angular/common/http';
-import { HttpClientBase, kBackend } from '@opra/client';
-import { AngularBackend } from './angular-backend.js';
-
-/**
- *
- * @class OpraAngularClient
- */
-export class OpraAngularClient extends HttpClientBase<AngularBackend.RequestOptions> {
-  declare [kBackend]: AngularBackend;
-
-  constructor(
-    httpClient: HttpClient,
-    serviceUrl: string,
-    options?: AngularBackend.Options,
-  ) {
-    super(new AngularBackend(httpClient, serviceUrl, options));
-  }
-
-  get defaults(): AngularBackend.RequestDefaults {
-    return this[kBackend].defaults;
-  }
-}

package/src/client.module.ts

@@ -1,156 +0,0 @@
-/* eslint-disable import-x/extensions */
-// @ts-ignore
-import { HttpClient } from '@angular/common/http';
-import {
-  type ModuleWithProviders,
-  NgModule,
-  type Provider,
-  Type,
-} from '@angular/core';
-import { kClient } from '@opra/client';
-import { OpraAngularClient } from './angular-client';
-import { OPRA_CLIENT_MODULE_OPTIONS } from './constants';
-import type {
-  OpraClientModuleAsyncOptions,
-  OpraClientModuleOptions,
-} from './interfaces/module-options.interface';
-
-@NgModule({})
-export class OpraClientModule {
-  public static registerClient(
-    options: OpraClientModuleOptions,
-  ): ModuleWithProviders<OpraClientModule> {
-    const CLIENT_TOKEN = options.token || OpraAngularClient;
-    return {
-      ngModule: OpraClientModule,
-      providers: [
-        {
-          provide: CLIENT_TOKEN,
-          deps: [HttpClient],
-          useFactory: (httpClient: HttpClient) =>
-            new OpraAngularClient(httpClient, options.serviceUrl, options),
-        },
-      ],
-    };
-  }
-
-  public static registerService<T>(
-    serviceClass: Type<T>,
-    options: OpraClientModuleOptions,
-  ): ModuleWithProviders<OpraClientModule> {
-    const SERVICE_TOKEN = options.token || serviceClass;
-    return {
-      ngModule: OpraClientModule,
-      providers: [
-        {
-          provide: SERVICE_TOKEN,
-          deps: [HttpClient],
-          useFactory: (httpClient: HttpClient) => {
-            const opraAngularClient = new OpraAngularClient(
-              httpClient,
-              options.serviceUrl,
-              options,
-            );
-            const service = new serviceClass(opraAngularClient);
-            service[kClient] = opraAngularClient;
-            return service;
-          },
-        },
-      ],
-    };
-  }
-
-  public static registerClientAsync(
-    options: OpraClientModuleAsyncOptions,
-  ): ModuleWithProviders<OpraClientModule> {
-    const CLIENT_TOKEN = options.token || OpraAngularClient;
-    const asyncProviders = this._createAsyncProviders(options);
-    return {
-      ngModule: OpraClientModule,
-      providers: [
-        ...asyncProviders,
-        {
-          provide: CLIENT_TOKEN,
-          deps: [HttpClient, OPRA_CLIENT_MODULE_OPTIONS],
-          useFactory: (httpClient: HttpClient, opts: OpraClientModuleOptions) =>
-            new OpraAngularClient(httpClient, opts.serviceUrl, opts),
-        },
-      ],
-    };
-  }
-
-  public static registerServiceAsync<T>(
-    serviceClass: Type<T>,
-    options: OpraClientModuleAsyncOptions,
-  ): ModuleWithProviders<OpraClientModule> {
-    const SERVICE_TOKEN = options.token || serviceClass;
-    const asyncProviders = this._createAsyncProviders(options);
-    return {
-      ngModule: OpraClientModule,
-      providers: [
-        ...asyncProviders,
-        {
-          provide: SERVICE_TOKEN,
-          deps: [HttpClient, OPRA_CLIENT_MODULE_OPTIONS],
-          useFactory: (
-            httpClient: HttpClient,
-            opts: OpraClientModuleOptions,
-          ) => {
-            const opraAngularClient = new OpraAngularClient(
-              httpClient,
-              opts.serviceUrl,
-              opts,
-            );
-            const service = new serviceClass(opraAngularClient);
-            service[kClient] = opraAngularClient;
-            return service;
-          },
-        },
-      ],
-    };
-  }
-
-  private static _createAsyncProviders(
-    options: OpraClientModuleAsyncOptions,
-  ): Provider[] {
-    if (options.useExisting || options.useFactory)
-      return [this._createAsyncOptionsProvider(options)];
-
-    if (options.useClass) {
-      return [
-        this._createAsyncOptionsProvider(options),
-        {
-          provide: options.useClass,
-          useClass: options.useClass,
-        },
-      ];
-    }
-
-    throw new Error(
-      'Invalid configuration. Must provide useFactory, useClass or useExisting',
-    );
-  }
-
-  private static _createAsyncOptionsProvider(
-    options: OpraClientModuleAsyncOptions,
-  ): Provider {
-    if (options.useFactory) {
-      return {
-        provide: OPRA_CLIENT_MODULE_OPTIONS,
-        useFactory: options.useFactory,
-        deps: options.deps || [],
-      };
-    }
-    const useClass = options.useClass || options.useExisting;
-    if (useClass) {
-      return {
-        provide: OPRA_CLIENT_MODULE_OPTIONS,
-        useFactory: o => o,
-        deps: [useClass],
-      };
-    }
-    throw new Error(
-      'Invalid configuration. Must provide useFactory, useClass or useExisting',
-    );
-  }
-}

package/src/constants.ts

@@ -1 +0,0 @@
-export const OPRA_CLIENT_MODULE_OPTIONS = 'OPRA_CLIENT_MODULE_OPTIONS';

package/src/interfaces/module-options.interface.ts

@@ -1,27 +0,0 @@
-import { InjectionToken, NgModule, Type } from '@angular/core';
-import type { StrictOmit } from 'ts-gems';
-import type { AngularBackend } from '../angular-backend';
-
-export type OpraClientModuleOptions = AngularBackend.Options & {
-  serviceUrl: string;
-  token?: string | InjectionToken<any>;
-};
-
-type _OpraClientModuleOptions = StrictOmit<OpraClientModuleOptions, 'token'>;
-
-export interface OpraModuleOptionsFactory {
-  createOptions(): Promise<_OpraClientModuleOptions> | _OpraClientModuleOptions;
-}
-
-export interface OpraClientModuleAsyncOptions extends Pick<
-  NgModule,
-  'imports' | 'providers'
-> {
-  token?: string | InjectionToken<any>;
-  useExisting?: Type<OpraModuleOptionsFactory>;
-  useClass?: Type<any>;
-  useFactory?: (
-    ...args: any[]
-  ) => Promise<_OpraClientModuleOptions> | _OpraClientModuleOptions;
-  deps?: any[];
-}

package/src/public_api.ts

@@ -1,5 +0,0 @@
-/* eslint-disable import-x/extensions */
-export * from './angular-backend';
-export * from './client.module';
-export * from './constants';
-export * from './interfaces/module-options.interface';

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../../tsconfig-base.json",
-  "include": ["src"],
-  "compilerOptions": {
-    "baseUrl": "./",
-    "paths": {
-      "@opra/client": ["../client/src"],
-      "@opra/common": ["../common/src"]
-    }
-  }
-}

package/tsconfig.lib.json

@@ -1,34 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ES2020",
-    "moduleResolution": "node",
-    "rootDir": "src",
-    "baseUrl": "./",
-    "paths": {
-      "@opra/client": ["../client/build"],
-      "@opra/common": ["../common/build"]
-    },
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "declaration": true,
-    "inlineSourceMap": true,
-    "inlineSources": true,
-    "skipLibCheck": true,
-    "emitDecoratorMetadata": false,
-    "experimentalDecorators": true,
-    "importHelpers": true,
-    "noEmit": false,
-    "lib": ["dom", "es2018"]
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist", "**/*.shim.ts", "**/*.spec.ts"],
-  "angularCompilerOptions": {
-    "compilationMode": "partial",
-    "strictTemplates": true,
-    "enableResourceInlining": true,
-    "incremental": true
-  }
-}