@google/earthengine 0.1.384 → 0.1.385

package/src/eeapiclient/multipart_request.ts

@@ -1,4 +1,3 @@
-// g3-format-clang
 import {Serializable, serialize} from './domain_object';
 
 export class MultipartRequest {
@@ -6,7 +5,7 @@ export class MultipartRequest {
   private _metadataPayload = '';
   private _payloadPromise: Promise<string>;
 
-  constructor(private files: File[], private _metadata?: {}|null) {
+  constructor(private files: File[], private _metadata?: {} | null) {
     this._boundary = Date.now().toString();
     if (_metadata) {
       this.addMetadata(_metadata);
@@ -18,7 +17,7 @@ export class MultipartRequest {
     return this._boundary;
   }
 
-  metadata(): {}|undefined|null {
+  metadata(): {} | undefined | null {
     return this._metadata;
   }
 
@@ -28,31 +27,37 @@ export class MultipartRequest {
 
   private addMetadata(metadata: {}): void {
     const json =
-        (metadata instanceof Serializable) ? serialize(metadata) : metadata;
+      metadata instanceof Serializable ? serialize(metadata) : metadata;
     this._metadataPayload +=
-        'Content-Type: application/json; charset=utf-8\r\n\r\n' +
-        JSON.stringify(json) + `\r\n--${this._boundary}\r\n`;
+      'Content-Type: application/json; charset=utf-8\r\n\r\n' +
+      JSON.stringify(json) +
+      `\r\n--${this._boundary}\r\n`;
   }
 
   private build(): Promise<string> {
     let payload = `--${this._boundary}\r\n`;
     payload += this._metadataPayload;
-    return Promise.all(this.files.map(f => this.encodeFile(f)))
-        .then(filePayloads => {
-          for (const filePayload of filePayloads) {
-            payload += filePayload;
-          }
-          payload += `\r\n--${this._boundary}--`;
-          return payload;
-        });
+    return Promise.all(this.files.map((f) => this.encodeFile(f))).then(
+      (filePayloads) => {
+        for (const filePayload of filePayloads) {
+          payload += filePayload;
+        }
+        payload += `\r\n--${this._boundary}--`;
+        return payload;
+      },
+    );
   }
 
   private encodeFile(file: File): Promise<string> {
     return this.base64EncodeFile(file).then(
-        base64Str => `Content-Type: ${file.type}\r\n` +
-            `Content-Disposition: form-data; name="file"; filename="${
-                         encodeURIComponent(file.name)}"\r\n` +
-            'Content-Transfer-Encoding: base64\r\n\r\n' + base64Str);
+      (base64Str) =>
+        `Content-Type: ${file.type}\r\n` +
+        `Content-Disposition: form-data; name="file"; filename="${encodeURIComponent(
+          file.name,
+        )}"\r\n` +
+        'Content-Transfer-Encoding: base64\r\n\r\n' +
+        base64Str,
+    );
   }
 
   private base64EncodeFile(file: File): Promise<string> {

package/src/eeapiclient/promise_api_client.ts

@@ -1,20 +1,32 @@
-// g3-format-clang
-import {ApiClient, toMakeRequestParams, toMultipartMakeRequestParams} from './api_client';
-import {ApiClientHookFactory, getRequestHook} from './api_request_hook';
+import {
+  ApiClient,
+  toMakeRequestParams,
+  toMultipartMakeRequestParams,
+} from './api_client';
+import {
+  ApiClientHookFactory,
+  getRequestHook,
+} from './api_request_hook';
 import {Serializable} from './domain_object';
-import {GeneratedInterface, GeneratedRequestParams} from './generated_types';
+import {
+  GeneratedInterface,
+  GeneratedRequestParams,
+} from './generated_types';
 
 import {PromiseRequestService} from './promise_request_service';
 
 export class PromiseApiClient extends ApiClient {
   constructor(
-      protected requestService: PromiseRequestService,
-      protected hookFactory: ApiClientHookFactory|null = null) {
+    protected requestService: PromiseRequestService,
+    protected hookFactory: ApiClientHookFactory | null = null,
+  ) {
     super();
   }
 
   protected $addHooksToRequest<T>(
-      requestParams: GeneratedRequestParams, promise: Promise<T>): Promise<T> {
+    requestParams: GeneratedRequestParams,
+    promise: Promise<T>,
+  ): Promise<T> {
     const hook = getRequestHook(this.hookFactory, requestParams);
     if (hook == null) {
       return promise;
@@ -22,34 +34,41 @@ export class PromiseApiClient extends ApiClient {
 
     hook.onBeforeSend();
     return promise.then(
-        (response) => {
-          hook.onSuccess(response);
-          return response;
-        },
-        (error) => {
-          hook.onError(error);
-          throw error;
-        });
+      (response) => {
+        hook.onSuccess(response);
+        return response;
+      },
+      (error) => {
+        hook.onError(error);
+        throw error;
+      },
+    );
   }
 
   /** Converts a gapi.client.Request to an Promise<T>. */
-  $request<T extends Serializable|GeneratedInterface>(
-      requestParams: GeneratedRequestParams): Promise<T> {
+  $request<T extends Serializable | GeneratedInterface>(
+    requestParams: GeneratedRequestParams,
+  ): Promise<T> {
     const responseCtor = requestParams.responseCtor || void 0;
     return this.$addHooksToRequest<T>(
-        requestParams,
-        this.requestService.send(
-            toMakeRequestParams(requestParams), responseCtor) as Promise<T>);
+      requestParams,
+      this.requestService.send(
+        toMakeRequestParams(requestParams),
+        responseCtor,
+      ) as Promise<T>,
+    );
   }
 
-  $uploadRequest<T extends Serializable|GeneratedInterface>(
-      requestParams: GeneratedRequestParams): Promise<T> {
+  $uploadRequest<T extends Serializable | GeneratedInterface>(
+    requestParams: GeneratedRequestParams,
+  ): Promise<T> {
     const responseCtor = requestParams.responseCtor || void 0;
     return this.$addHooksToRequest<T>(
-        requestParams,
-        toMultipartMakeRequestParams(requestParams)
-            .then(
-                params => this.requestService.send(params, responseCtor) as
-                    Promise<T>));
+      requestParams,
+      toMultipartMakeRequestParams(requestParams).then(
+        (params) =>
+          this.requestService.send(params, responseCtor) as Promise<T>,
+      ),
+    );
   }
 }

package/src/eeapiclient/promise_request_service.ts

@@ -1,15 +1,22 @@
-// g3-format-clang
-import {deserialize, Serializable, SerializableCtor} from './domain_object';
-import {MakeRequestParams, processParams} from './request_params';
+import {
+  deserialize,
+  Serializable,
+  SerializableCtor,
+} from './domain_object';
+import {
+  MakeRequestParams,
+  processParams,
+} from './request_params';
 
 export abstract class PromiseRequestService {
   send<T extends Serializable>(
-      params: MakeRequestParams,
-      responseCtor?: SerializableCtor<T>): Promise<T> {
+    params: MakeRequestParams,
+    responseCtor?: SerializableCtor<T>,
+  ): Promise<T> {
     processParams(params);
-    return this.makeRequest(params).then(
-        (response) =>
-            responseCtor ? deserialize(responseCtor, response) : response as T);
+    return this.makeRequest(params).then((response) =>
+      responseCtor ? deserialize(responseCtor, response) : (response as T),
+    );
   }
 
   abstract makeRequest(params: MakeRequestParams): Promise<{}>;

package/src/eeapiclient/request_params.ts

@@ -1,10 +1,9 @@
-// g3-format-clang
 import * as httpCors from 'goog:goog.net.rpc.HttpCors';
 
 import {GeneratedQueryParams} from './generated_types';
 
 /** Available HTTP methods supported by Google APIs */
-export type HttpMethod = 'GET'|'POST'|'PUT'|'PATCH'|'DELETE';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 
 /**
  * {@link HttpMethod} come directly from the discovery file as strings. The code
@@ -44,7 +43,7 @@ export enum StreamingType {
   NONE = 'NONE',
   CLIENT_SIDE = 'CLIENT_SIDE',
   SERVER_SIDE = 'SERVER_SIDE',
-  BIDIRECTONAL = 'BIDIRECTONAL'
+  BIDIRECTONAL = 'BIDIRECTONAL',
 }
 
 /**
@@ -58,7 +57,7 @@ export interface MakeRequestParams {
    * custom HTTP methods. You can use {@link HttpMethodEnum#isHttpMethod}
    * to check if the httpMethod is of type {@link HttpMethod}.
    */
-  httpMethod: HttpMethod|string;
+  httpMethod: HttpMethod | string;
   /** The id of the called method, from discovery. */
   methodId?: string;
   // tslint:disable-next-line:no-any
@@ -97,8 +96,10 @@ export function processParams(params: MakeRequestParams) {
  * therefore this function can be loose about type-checking the fields.
  */
 export function buildQueryParams(
-    params: {}, mapping: Record<string, string>,
-    passthroughParams: Record<string, string> = {}): GeneratedQueryParams {
+  params: {},
+  mapping: Record<string, string>,
+  passthroughParams: Record<string, string> = {},
+): GeneratedQueryParams {
   const paramsMap = params as unknown as GeneratedQueryParams;
 
   const urlQueryParams: GeneratedQueryParams = passthroughParams;
@@ -110,8 +111,11 @@ export function buildQueryParams(
   return urlQueryParams;
 }
 
-const simpleCorsAllowedHeaders: string[] =
-    ['accept', 'accept-language', 'content-language'];
+const simpleCorsAllowedHeaders: string[] = [
+  'accept',
+  'accept-language',
+  'content-language',
+];
 
 const simpleCorsAllowedMethods: string[] = ['GET', 'HEAD', 'POST'];
 
@@ -158,8 +162,11 @@ export function bypassCorsPreflight(params: MakeRequestParams) {
     }
   }
 
-  if (params.body != null || params.httpMethod === 'PUT' ||
-      params.httpMethod === 'POST') {
+  if (
+    params.body != null ||
+    params.httpMethod === 'PUT' ||
+    params.httpMethod === 'POST'
+  ) {
     // Normally, HttpClient detects the application/json Content-Type based on
     // the body of the request. We need to explicitly set it in the
     // pre-generateEncodedHttpHeadersOverwriteParam so that the header
@@ -175,20 +182,26 @@ export function bypassCorsPreflight(params: MakeRequestParams) {
 
   if (hasUnsafeHeaders) {
     const finalParam =
-        httpCors.generateEncodedHttpHeadersOverwriteParam(unsafeHeaders);
+      httpCors.generateEncodedHttpHeadersOverwriteParam(unsafeHeaders);
     addQueryParameter(params, httpCors.HTTP_HEADERS_PARAM_NAME, finalParam);
   }
   params.headers = safeHeaders;
 
   if (!simpleCorsAllowedMethods.includes(params.httpMethod)) {
     addQueryParameter(
-        params, httpCors.HTTP_METHOD_PARAM_NAME, params.httpMethod);
+      params,
+      httpCors.HTTP_METHOD_PARAM_NAME,
+      params.httpMethod,
+    );
     params.httpMethod = 'POST';
   }
 }
 
 function addQueryParameter(
-    params: MakeRequestParams, key: string, value: string) {
+  params: MakeRequestParams,
+  key: string,
+  value: string,
+) {
   if (params.queryParams) {
     params.queryParams[key] = value;
   } else {

package/src/eeapiclient/request_params_test.ts

@@ -1,7 +1,10 @@
-// g3-format-clang
 import 'jasmine';
 
-import {buildQueryParams, bypassCorsPreflight, MakeRequestParams} from './request_params';
+import {
+  buildQueryParams,
+  bypassCorsPreflight,
+  MakeRequestParams,
+} from './request_params';
 
 describe('buildQueryParams', () => {
   const PARAMS_MAP = {
@@ -100,7 +103,7 @@ describe('bypassCorsPreflight', () => {
     expect(params.headers).toEqual({'Content-Type': 'text/plain'});
     expect(params.httpMethod).toEqual('POST');
     expect(params.queryParams).toEqual({
-      '$httpHeaders': 'Content-Type%3Aapplication%2Fjson%0D%0A'
+      '$httpHeaders': 'Content-Type%3Aapplication%2Fjson%0D%0A',
     });
   });
 
@@ -109,15 +112,16 @@ describe('bypassCorsPreflight', () => {
       path: 'v1/whatever',
       httpMethod: 'POST',
       methodId: 'someservice.whatever.post',
-      headers:
-          {'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'},
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+      },
     };
     bypassCorsPreflight(params);
     expect(params.headers).toEqual({'Content-Type': 'text/plain'});
     expect(params.httpMethod).toEqual('POST');
     expect(params.queryParams).toEqual({
       '$httpHeaders':
-          'Content-Type%3Aapplication%2Fx-www-form-urlencoded%3Bcharset%3DUTF-8%0D%0A',
+        'Content-Type%3Aapplication%2Fx-www-form-urlencoded%3Bcharset%3DUTF-8%0D%0A',
     });
   });
 
@@ -134,26 +138,25 @@ describe('bypassCorsPreflight', () => {
     expect(params.httpMethod).toEqual('POST');
     expect(params.queryParams).toEqual({
       '$httpMethod': 'PUT',
-      '$httpHeaders': 'Content-Type%3Aapplication%2Fjson%0D%0A'
+      '$httpHeaders': 'Content-Type%3Aapplication%2Fjson%0D%0A',
     });
   });
 
-  it('handles would-trigger-preflight cors method with optional query params',
-     () => {
-       const params: MakeRequestParams = {
-         path: 'v1/whatever',
-         httpMethod: 'PUT',
-         methodId: 'someservice.whatever.put',
-         headers: {},
-       };
-       bypassCorsPreflight(params);
-       expect(params.headers).toEqual({'Content-Type': 'text/plain'});
-       expect(params.httpMethod).toEqual('POST');
-       expect(params.queryParams).toEqual({
-         '$httpMethod': 'PUT',
-         '$httpHeaders': 'Content-Type%3Aapplication%2Fjson%0D%0A'
-       });
-     });
+  it('handles would-trigger-preflight cors method with optional query params', () => {
+    const params: MakeRequestParams = {
+      path: 'v1/whatever',
+      httpMethod: 'PUT',
+      methodId: 'someservice.whatever.put',
+      headers: {},
+    };
+    bypassCorsPreflight(params);
+    expect(params.headers).toEqual({'Content-Type': 'text/plain'});
+    expect(params.httpMethod).toEqual('POST');
+    expect(params.queryParams).toEqual({
+      '$httpMethod': 'PUT',
+      '$httpHeaders': 'Content-Type%3Aapplication%2Fjson%0D%0A',
+    });
+  });
 
   it('handles simple cors headers', () => {
     const params: MakeRequestParams = {
@@ -183,57 +186,55 @@ describe('bypassCorsPreflight', () => {
     expect(params.queryParams).toEqual({'$httpHeaders': 'foo%3Abar%0D%0A'});
   });
 
-  it('handles would-trigger-preflight cors headers without safe headers',
-     () => {
-       const params: MakeRequestParams = {
-         path: 'v1/whatever',
-         httpMethod: 'GET',
-         methodId: 'someservice.whatever.get',
-         headers: {'foo': 'bar'},
-         queryParams: {},
-       };
-       bypassCorsPreflight(params);
-       expect(params.headers).toEqual({});
-       expect(params.httpMethod).toEqual('GET');
-       expect(params.queryParams).toEqual({'$httpHeaders': 'foo%3Abar%0D%0A'});
-     });
-
-  it('handles would-trigger-preflight cors headers with existing query params',
-     () => {
-       const params: MakeRequestParams = {
-         path: 'v1/whatever',
-         httpMethod: 'GET',
-         methodId: 'someservice.whatever.get',
-         headers: {'accept-language': 'de', 'foo': 'bar', 'a': 'b'},
-         queryParams: {'hello': 'world'},
-       };
-       bypassCorsPreflight(params);
-       expect(params.headers).toEqual({'accept-language': 'de'});
-       expect(params.httpMethod).toEqual('GET');
-       expect(params.queryParams).toEqual({
-         'hello': 'world',
-         '$httpHeaders': 'foo%3Abar%0D%0Aa%3Ab%0D%0A'
-       });
-     });
-
-  it('handles would-trigger-preflight cors headers and method with existing query params',
-     () => {
-       const params: MakeRequestParams = {
-         path: 'v1/whatever',
-         httpMethod: 'PUT',
-         methodId: 'someservice.whatever.put',
-         headers: {'accept-language': 'de', 'foo': 'bar'},
-         queryParams: {'hello': 'world'},
-       };
-       bypassCorsPreflight(params);
-       expect(params.headers)
-           .toEqual({'accept-language': 'de', 'Content-Type': 'text/plain'});
-       expect(params.httpMethod).toEqual('POST');
-       expect(params.queryParams).toEqual({
-         'hello': 'world',
-         '$httpHeaders':
-             'foo%3Abar%0D%0AContent-Type%3Aapplication%2Fjson%0D%0A',
-         '$httpMethod': 'PUT'
-       });
-     });
+  it('handles would-trigger-preflight cors headers without safe headers', () => {
+    const params: MakeRequestParams = {
+      path: 'v1/whatever',
+      httpMethod: 'GET',
+      methodId: 'someservice.whatever.get',
+      headers: {'foo': 'bar'},
+      queryParams: {},
+    };
+    bypassCorsPreflight(params);
+    expect(params.headers).toEqual({});
+    expect(params.httpMethod).toEqual('GET');
+    expect(params.queryParams).toEqual({'$httpHeaders': 'foo%3Abar%0D%0A'});
+  });
+
+  it('handles would-trigger-preflight cors headers with existing query params', () => {
+    const params: MakeRequestParams = {
+      path: 'v1/whatever',
+      httpMethod: 'GET',
+      methodId: 'someservice.whatever.get',
+      headers: {'accept-language': 'de', 'foo': 'bar', 'a': 'b'},
+      queryParams: {'hello': 'world'},
+    };
+    bypassCorsPreflight(params);
+    expect(params.headers).toEqual({'accept-language': 'de'});
+    expect(params.httpMethod).toEqual('GET');
+    expect(params.queryParams).toEqual({
+      'hello': 'world',
+      '$httpHeaders': 'foo%3Abar%0D%0Aa%3Ab%0D%0A',
+    });
+  });
+
+  it('handles would-trigger-preflight cors headers and method with existing query params', () => {
+    const params: MakeRequestParams = {
+      path: 'v1/whatever',
+      httpMethod: 'PUT',
+      methodId: 'someservice.whatever.put',
+      headers: {'accept-language': 'de', 'foo': 'bar'},
+      queryParams: {'hello': 'world'},
+    };
+    bypassCorsPreflight(params);
+    expect(params.headers).toEqual({
+      'accept-language': 'de',
+      'Content-Type': 'text/plain',
+    });
+    expect(params.httpMethod).toEqual('POST');
+    expect(params.queryParams).toEqual({
+      'hello': 'world',
+      '$httpHeaders': 'foo%3Abar%0D%0AContent-Type%3Aapplication%2Fjson%0D%0A',
+      '$httpMethod': 'PUT',
+    });
+  });
 });