@futdevpro/fsm-dynamo 1.16.33 → 1.16.34

package/src/_models/control-models/http/http-response.model-base.spec.ts

@@ -1,46 +1,46 @@
-import { DyFM_HttpResponseBase } from './http-response.model-base';
-import { DyFM_HttpEventType } from '../../../_enums/http/http-event-type.enum';
-
-class TestHttpResponse extends DyFM_HttpResponseBase {
-  constructor(set?: Partial<DyFM_HttpResponseBase>) {
-    super(set);
-  }
-}
-
-describe('| DyFM_HttpResponseBase', (): void => {
-  it('| should create an instance with default values', (): void => {
-    const response = new TestHttpResponse({ url: null });
-
-    expect(response.status).toBe(200);
-    expect(response.statusText).toBe('OK');
-    expect(response.headers).toBeTruthy();
-    expect(response.url).toBeNull();
-  });
-
-  it('| should create an instance with custom values', (): void => {
-    const response = new TestHttpResponse({
-      status: 404,
-      statusText: 'Not Found',
-      url: 'https://example.com/api/test',
-      ok: false,
-      type: DyFM_HttpEventType.response,
-    });
-
-    expect(response.status).toBe(404);
-    expect(response.statusText).toBe('Not Found');
-    expect(response.url).toBe('https://example.com/api/test');
-    expect(response.ok).toBe(false);
-    expect(response.type).toBe(DyFM_HttpEventType.response);
-  });
-
-  it('| should create an instance with partial values', (): void => {
-    const response = new TestHttpResponse({
-      status: 500,
-    });
-
-    expect(response.status).toBe(500);
-    expect(response.statusText).toBe('OK');
-    expect(response.headers).toBeTruthy();
-  });
-});
-
+import { DyFM_HttpResponseBase } from './http-response.model-base';
+import { DyFM_HttpEventType } from '../../../_enums/http/http-event-type.enum';
+
+class TestHttpResponse extends DyFM_HttpResponseBase {
+  constructor(set?: Partial<DyFM_HttpResponseBase>) {
+    super(set);
+  }
+}
+
+describe('| DyFM_HttpResponseBase', (): void => {
+  it('| should create an instance with default values', (): void => {
+    const response = new TestHttpResponse({ url: null });
+
+    expect(response.status).toBe(200);
+    expect(response.statusText).toBe('OK');
+    expect(response.headers).toBeTruthy();
+    expect(response.url).toBeNull();
+  });
+
+  it('| should create an instance with custom values', (): void => {
+    const response = new TestHttpResponse({
+      status: 404,
+      statusText: 'Not Found',
+      url: 'https://example.com/api/test',
+      ok: false,
+      type: DyFM_HttpEventType.response,
+    });
+
+    expect(response.status).toBe(404);
+    expect(response.statusText).toBe('Not Found');
+    expect(response.url).toBe('https://example.com/api/test');
+    expect(response.ok).toBe(false);
+    expect(response.type).toBe(DyFM_HttpEventType.response);
+  });
+
+  it('| should create an instance with partial values', (): void => {
+    const response = new TestHttpResponse({
+      status: 500,
+    });
+
+    expect(response.status).toBe(500);
+    expect(response.statusText).toBe('OK');
+    expect(response.headers).toBeTruthy();
+  });
+});
+

package/src/_models/control-models/http/http-response.model-base.ts

@@ -1,58 +1,58 @@
-import { DyFM_HttpEventType } from '../../../_enums/http/http-event-type.enum';
-import { DyFM_HttpHeaders } from './http-headers.control-model';
-
-/**
- * Base class for both `HttpResponse` and `HttpHeaderResponse`.
- *
- * @publicApi
- * 
- * @example
- * ```ts
- * const response: DyFM_HttpResponseBase = new DyFM_HttpResponseBase({
- *   status: 200,
- *   statusText: 'OK',
- *   url: 'https://example.com/api/response',
- * });
- * ```
- */
-export abstract class DyFM_HttpResponseBase {
-  /**
-   * All response headers.
-   */
-  readonly headers: DyFM_HttpHeaders = new DyFM_HttpHeaders();
-  /**
-   * Response status code.
-   */
-  readonly status: number = 200;
-  /**
-   * Textual description of response status code, defaults to OK.
-   *
-   * Do not depend on this.
-   */
-  readonly statusText: string = 'OK';
-  /**
-   * URL of the resource retrieved, or null if not available.
-   */
-  readonly url: string | null;
-  /**
-   * Whether the status code falls in the 2xx range.
-   */
-  readonly ok: boolean;
-  /**
-   * Type of the response, narrowed to either the full response or the header.
-   */
-  readonly type: DyFM_HttpEventType.response | DyFM_HttpEventType.responseHeader;
-  /**
-   * Super-constructor for all responses.
-   *
-   * The single parameter accepted is an initialization hash. Any properties
-   * of the response passed there will override the default values.
-   */
-  constructor(
-    set: Partial<DyFM_HttpResponseBase>
-  ) {
-    if (set) {
-      Object.assign(this, set);
-    }
-  }
+import { DyFM_HttpEventType } from '../../../_enums/http/http-event-type.enum';
+import { DyFM_HttpHeaders } from './http-headers.control-model';
+
+/**
+ * Base class for both `HttpResponse` and `HttpHeaderResponse`.
+ *
+ * @publicApi
+ * 
+ * @example
+ * ```ts
+ * const response: DyFM_HttpResponseBase = new DyFM_HttpResponseBase({
+ *   status: 200,
+ *   statusText: 'OK',
+ *   url: 'https://example.com/api/response',
+ * });
+ * ```
+ */
+export abstract class DyFM_HttpResponseBase {
+  /**
+   * All response headers.
+   */
+  readonly headers: DyFM_HttpHeaders = new DyFM_HttpHeaders();
+  /**
+   * Response status code.
+   */
+  readonly status: number = 200;
+  /**
+   * Textual description of response status code, defaults to OK.
+   *
+   * Do not depend on this.
+   */
+  readonly statusText: string = 'OK';
+  /**
+   * URL of the resource retrieved, or null if not available.
+   */
+  readonly url: string | null;
+  /**
+   * Whether the status code falls in the 2xx range.
+   */
+  readonly ok: boolean;
+  /**
+   * Type of the response, narrowed to either the full response or the header.
+   */
+  readonly type: DyFM_HttpEventType.response | DyFM_HttpEventType.responseHeader;
+  /**
+   * Super-constructor for all responses.
+   *
+   * The single parameter accepted is an initialization hash. Any properties
+   * of the response passed there will override the default values.
+   */
+  constructor(
+    set: Partial<DyFM_HttpResponseBase>
+  ) {
+    if (set) {
+      Object.assign(this, set);
+    }
+  }
 }

package/src/_models/control-models/poll.control-model.spec.ts

@@ -1,63 +1,63 @@
-
-import { DyFM_Error } from './error.control-model';
-import { DyFM_Poll } from './poll.control-model';
-
-describe('| DyFM_Poll', () => {
-  let pollInstance: DyFM_Poll<number>;
-  let pollDo: jasmine.Spy<(...args: any[]) => Promise<number>>;
-  let pollWhile: jasmine.Spy<(res: number) => boolean>;
-  let pollEnd: jasmine.Spy<(res: number) => void>;
-
-  beforeEach(() => {
-    pollDo = jasmine.createSpy('pollDo').and.returnValue(Promise.resolve(1));
-    pollWhile = jasmine.createSpy('pollWhile').and.returnValue(true);
-    pollEnd = jasmine.createSpy('pollEnd');
-
-    pollInstance = new DyFM_Poll<number>({
-      pollDo,
-      pollWhile,
-      pollEnd,
-      pollDelay: 0,
-      pollPeriod: 1000,
-      stopOnFail: true,
-    });
-  });
-
-  xit('should initialize with the correct properties', () => {
-    expect(pollInstance.running).toBeTrue();
-    expect(pollDo).toHaveBeenCalled();
-  });
-
-  it('| should stop polling when stop is called', () => {
-    pollInstance.stop();
-    expect(pollInstance.running).toBeFalse();
-  });
-
-  xit('should call pollEnd and stop polling when pollWhile returns false', async () => {
-    pollWhile.and.returnValue(false);
-    await pollDo.calls.mostRecent().returnValue;
-    expect(pollEnd).toHaveBeenCalledWith(1);
-    expect(pollInstance.running).toBeFalse();
-  });
-
-  xit('should throw DyFM_Error when pollDo fails and stopOnFail is true', async () => {
-    pollDo.and.returnValue(Promise.reject('error'));
-    try {
-      await pollDo.calls.mostRecent().returnValue;
-    } catch (error) {
-      expect(error).toEqual(jasmine.any(DyFM_Error));
-    }
-    expect(pollInstance.running).toBeFalse();
-  });
-
-  xit('should restart polling with new arguments', () => {
-    const newArgs = [2];
-    pollInstance.restartPoll(newArgs);
-    expect(pollDo).toHaveBeenCalledWith(...newArgs);
-  });
-
-  xit('should restart polling with initial arguments if no new arguments are provided', () => {
-    pollInstance.restartPoll();
-    expect(pollDo).toHaveBeenCalledWith(...pollInstance['args']);
-  });
-});
+
+import { DyFM_Error } from './error.control-model';
+import { DyFM_Poll } from './poll.control-model';
+
+describe('| DyFM_Poll', () => {
+  let pollInstance: DyFM_Poll<number>;
+  let pollDo: jasmine.Spy<(...args: any[]) => Promise<number>>;
+  let pollWhile: jasmine.Spy<(res: number) => boolean>;
+  let pollEnd: jasmine.Spy<(res: number) => void>;
+
+  beforeEach(() => {
+    pollDo = jasmine.createSpy('pollDo').and.returnValue(Promise.resolve(1));
+    pollWhile = jasmine.createSpy('pollWhile').and.returnValue(true);
+    pollEnd = jasmine.createSpy('pollEnd');
+
+    pollInstance = new DyFM_Poll<number>({
+      pollDo,
+      pollWhile,
+      pollEnd,
+      pollDelay: 0,
+      pollPeriod: 1000,
+      stopOnFail: true,
+    });
+  });
+
+  xit('should initialize with the correct properties', () => {
+    expect(pollInstance.running).toBeTrue();
+    expect(pollDo).toHaveBeenCalled();
+  });
+
+  it('| should stop polling when stop is called', () => {
+    pollInstance.stop();
+    expect(pollInstance.running).toBeFalse();
+  });
+
+  xit('should call pollEnd and stop polling when pollWhile returns false', async () => {
+    pollWhile.and.returnValue(false);
+    await pollDo.calls.mostRecent().returnValue;
+    expect(pollEnd).toHaveBeenCalledWith(1);
+    expect(pollInstance.running).toBeFalse();
+  });
+
+  xit('should throw DyFM_Error when pollDo fails and stopOnFail is true', async () => {
+    pollDo.and.returnValue(Promise.reject('error'));
+    try {
+      await pollDo.calls.mostRecent().returnValue;
+    } catch (error) {
+      expect(error).toEqual(jasmine.any(DyFM_Error));
+    }
+    expect(pollInstance.running).toBeFalse();
+  });
+
+  xit('should restart polling with new arguments', () => {
+    const newArgs = [2];
+    pollInstance.restartPoll(newArgs);
+    expect(pollDo).toHaveBeenCalledWith(...newArgs);
+  });
+
+  xit('should restart polling with initial arguments if no new arguments are provided', () => {
+    pollInstance.restartPoll();
+    expect(pollDo).toHaveBeenCalledWith(...pollInstance['args']);
+  });
+});

package/src/_models/control-models/poll.control-model.ts

@@ -1,151 +1,151 @@
-import { Subscription, timer } from 'rxjs';
-import { DyFM_Error } from './error.control-model';
-import { second } from '../../_collections/constants/times.const';
-import { DyFM_Async } from '../../_collections/utils/async.util';
-
-
-/**
- * DynamoFSM_Poll is a predefined class is
- * for polling a specific endpoint
- * waiting a specific result
- * 
- * @example
- * ```ts
- * const poll: DyFM_Poll<string> = new DyFM_Poll({
- *   name: 'My Poll',
- *   pollDo: async () => {
- *     return 'Poll result';
- *   },
- * });
- * ```
- */
-export class DyFM_Poll<T> {
-  name: string;
-
-  poll: Subscription;
-  running: boolean;
-
-  /**
-   * The function that will be called to poll the endpoint,
-   * it will be called every pollPeriod
-   */
-  readonly pollDo: (...args) => Promise<T>;
-  /**
-   * The function that will be called to check if the poll should continue,
-   * if this returns false, the poll will end
-   */
-  readonly pollWhile: (res: T) => boolean;
-  /**
-   * The function that will be called to end the poll
-   */
-  readonly pollEnd?: (res: T) => void;
-  /**
-   * The function that will be called to handle the error
-   */
-  readonly pollDoError?: (error: any) => void;
-  readonly args?: any[];
-  readonly pollDelay: number = 0;
-  readonly pollPeriod: number = 3 * second;
-  readonly stopOnFail: boolean = false;
-  readonly delayFirst: boolean = false;
-
-  constructor(
-    set: Partial<DyFM_Poll<T>> 
-  ) {
-    try {
-      Object.assign(this, set);
-
-      if (set.pollPeriod === 0) {
-        console.error(
-          'DYNAMO ERROR: creating polls with 0ms period is not supported! ' +
-          '(it will reset to 1000ms (1s))',
-        );
-        this.pollPeriod = 1 * second;
-      }
-
-      if (this.pollPeriod < 300) {
-        console.warn(
-          'DYNAMO WARNING: creating polls with less than 300ms period is not recommended!'
-        );
-      }
-
-      this.name = set.name ?? 'Unnamed DyFM_Poll';
-
-      this.stopOnFail = set.stopOnFail;
-      this.startPoll(this.args);
-    } catch (error) {
-      throw new DyFM_Error({
-        message: 'DyFM_Poll construcion failed.'
-      });
-    }
-  }
-
-  /**
-   * Starts the poll
-   * @param args - The arguments to pass to the pollDo function
-   */
-  private async startPoll(...args: any[]): Promise<void> {
-    try {
-      if (this.delayFirst) {
-        await DyFM_Async.wait(this.pollDelay);
-      }
-      this.poll = timer(this.pollDelay, this.pollPeriod).subscribe(async (): Promise<void> => {
-        await this.pollDo(...args).then((res: T): void => {
-          if (!this.pollWhile(res)) {
-            this.end(res);
-          }
-        }).catch((error): void => {
-          if (this.stopOnFail) {
-            this.stop();
-          }
-
-          if (this.pollDoError) {
-            this.pollDoError(error);
-          } else {
-            throw new DyFM_Error({
-              message: `DYNAMO ERROR: ` +
-                `\nDynamoPoll: "${this.name}" pollDo was UNSUCCESSFUL`,
-              error: error,
-            });
-          }
-        });
-      });
-      this.running = true;
-    } catch (error) {
-      throw new DyFM_Error({
-        message: 'DYNAMO ERROR: \nDynamoPoll: startPoll was UNSUCCESSFUL',
-        error: error,
-      });
-    }
-  }
-
-  /**
-   * Restarts the poll
-   * @param args - The arguments to pass to the pollDo function
-   */
-  restartPoll(args?: any[]): void {
-    try {
-      if (args) {
-        this.startPoll(args);
-      } else {
-        this.startPoll(this.args);
-      }
-    } catch (error) {
-      throw new DyFM_Error({
-        message: 'DYNAMO ERROR: \nDynamoPoll: restartPoll was UNSUCCESSFUL',
-        error: error,
-      });
-    }
-  }
-
-  stop(): void {
-    this.poll.unsubscribe();
-    this.running = false;
-  }
-
-  end(result: T): void {
-    this.poll.unsubscribe();
-    this.pollEnd?.(result);
-    this.running = false;
-  }
-}
+import { Subscription, timer } from 'rxjs';
+import { DyFM_Error } from './error.control-model';
+import { second } from '../../_collections/constants/times.const';
+import { DyFM_Async } from '../../_collections/utils/async.util';
+
+
+/**
+ * DynamoFSM_Poll is a predefined class is
+ * for polling a specific endpoint
+ * waiting a specific result
+ * 
+ * @example
+ * ```ts
+ * const poll: DyFM_Poll<string> = new DyFM_Poll({
+ *   name: 'My Poll',
+ *   pollDo: async () => {
+ *     return 'Poll result';
+ *   },
+ * });
+ * ```
+ */
+export class DyFM_Poll<T> {
+  name: string;
+
+  poll: Subscription;
+  running: boolean;
+
+  /**
+   * The function that will be called to poll the endpoint,
+   * it will be called every pollPeriod
+   */
+  readonly pollDo: (...args) => Promise<T>;
+  /**
+   * The function that will be called to check if the poll should continue,
+   * if this returns false, the poll will end
+   */
+  readonly pollWhile: (res: T) => boolean;
+  /**
+   * The function that will be called to end the poll
+   */
+  readonly pollEnd?: (res: T) => void;
+  /**
+   * The function that will be called to handle the error
+   */
+  readonly pollDoError?: (error: any) => void;
+  readonly args?: any[];
+  readonly pollDelay: number = 0;
+  readonly pollPeriod: number = 3 * second;
+  readonly stopOnFail: boolean = false;
+  readonly delayFirst: boolean = false;
+
+  constructor(
+    set: Partial<DyFM_Poll<T>> 
+  ) {
+    try {
+      Object.assign(this, set);
+
+      if (set.pollPeriod === 0) {
+        console.error(
+          'DYNAMO ERROR: creating polls with 0ms period is not supported! ' +
+          '(it will reset to 1000ms (1s))',
+        );
+        this.pollPeriod = 1 * second;
+      }
+
+      if (this.pollPeriod < 300) {
+        console.warn(
+          'DYNAMO WARNING: creating polls with less than 300ms period is not recommended!'
+        );
+      }
+
+      this.name = set.name ?? 'Unnamed DyFM_Poll';
+
+      this.stopOnFail = set.stopOnFail;
+      this.startPoll(this.args);
+    } catch (error) {
+      throw new DyFM_Error({
+        message: 'DyFM_Poll construcion failed.'
+      });
+    }
+  }
+
+  /**
+   * Starts the poll
+   * @param args - The arguments to pass to the pollDo function
+   */
+  private async startPoll(...args: any[]): Promise<void> {
+    try {
+      if (this.delayFirst) {
+        await DyFM_Async.wait(this.pollDelay);
+      }
+      this.poll = timer(this.pollDelay, this.pollPeriod).subscribe(async (): Promise<void> => {
+        await this.pollDo(...args).then((res: T): void => {
+          if (!this.pollWhile(res)) {
+            this.end(res);
+          }
+        }).catch((error): void => {
+          if (this.stopOnFail) {
+            this.stop();
+          }
+
+          if (this.pollDoError) {
+            this.pollDoError(error);
+          } else {
+            throw new DyFM_Error({
+              message: `DYNAMO ERROR: ` +
+                `\nDynamoPoll: "${this.name}" pollDo was UNSUCCESSFUL`,
+              error: error,
+            });
+          }
+        });
+      });
+      this.running = true;
+    } catch (error) {
+      throw new DyFM_Error({
+        message: 'DYNAMO ERROR: \nDynamoPoll: startPoll was UNSUCCESSFUL',
+        error: error,
+      });
+    }
+  }
+
+  /**
+   * Restarts the poll
+   * @param args - The arguments to pass to the pollDo function
+   */
+  restartPoll(args?: any[]): void {
+    try {
+      if (args) {
+        this.startPoll(args);
+      } else {
+        this.startPoll(this.args);
+      }
+    } catch (error) {
+      throw new DyFM_Error({
+        message: 'DYNAMO ERROR: \nDynamoPoll: restartPoll was UNSUCCESSFUL',
+        error: error,
+      });
+    }
+  }
+
+  stop(): void {
+    this.poll.unsubscribe();
+    this.running = false;
+  }
+
+  end(result: T): void {
+    this.poll.unsubscribe();
+    this.pollEnd?.(result);
+    this.running = false;
+  }
+}