@bitblit/ngx-acute-common 5.0.512-alpha

package/src/pipes/order-by.pipe.ts

@@ -0,0 +1,58 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({ name: 'acuteOrderBy', pure: false, standalone: true })
+export class OrderByPipe implements PipeTransform {
+  static _orderByComparator(a: any, b: any): number {
+    if (isNaN(parseFloat(a)) || !isFinite(a) || isNaN(parseFloat(b)) || !isFinite(b)) {
+      //Isn't a number so lowercase the string to properly compare
+      if (String(a).toLowerCase() < String(b).toLowerCase()) return -1;
+      if (String(a).toLowerCase() > String(b).toLowerCase()) return 1;
+    } else {
+      //Parse strings as numbers to compare properly
+      if (parseFloat(a) < parseFloat(b)) return -1;
+      if (parseFloat(a) > parseFloat(b)) return 1;
+    }
+
+    return 0; //equal each other
+  }
+
+  transform(input: any, [config = '+']): any {
+    if (!Array.isArray(input)) return input;
+
+    if (!Array.isArray(config) || (Array.isArray(config) && config.length == 1)) {
+      const propertyToCheck: string = !Array.isArray(config) ? config : config[0];
+      const desc = propertyToCheck.substr(0, 1) == '-';
+
+      //Basic array
+      if (!propertyToCheck || propertyToCheck == '-' || propertyToCheck == '+') {
+        return !desc ? input.sort() : input.sort().reverse();
+      } else {
+        const property: string =
+          propertyToCheck.substr(0, 1) == '+' || propertyToCheck.substr(0, 1) == '-' ? propertyToCheck.substr(1) : propertyToCheck;
+
+        return input.sort(function (a: any, b: any) {
+          return !desc
+            ? OrderByPipe._orderByComparator(a[property], b[property])
+            : -OrderByPipe._orderByComparator(a[property], b[property]);
+        });
+      }
+    } else {
+      //Loop over property of the array in order and sort
+      return input.sort(function (a: any, b: any) {
+        for (let i: number = 0; i < config.length; i++) {
+          const desc = config[i].substr(0, 1) == '-';
+          const property = config[i].substr(0, 1) == '+' || config[i].substr(0, 1) == '-' ? config[i].substr(1) : config[i];
+
+          const comparison = !desc
+            ? OrderByPipe._orderByComparator(a[property], b[property])
+            : -OrderByPipe._orderByComparator(a[property], b[property]);
+
+          //Don't return 0 yet in case of needing to sort by next property
+          if (comparison != 0) return comparison;
+        }
+
+        return 0; //equal each other
+      });
+    }
+  }
+}

package/src/pipes/percent-formatted.pipe.ts

@@ -0,0 +1,9 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import {NumberRatchet} from "@bitblit/ratchet-common/lang/number-ratchet";
+
+@Pipe({ name: 'acutePercent' , standalone: true })
+export class PercentFormattedPipe implements PipeTransform {
+  transform(input: number): string {
+    return NumberRatchet.pctFormatted(input);
+  }
+}

package/src/pipes/plural.pipe.ts

@@ -0,0 +1,14 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({ name: 'acutePlural'  , standalone: true})
+export class PluralPipe implements PipeTransform {
+
+  transform(input: number, label: string, pluralLabel: string = ''): string {
+    input = input || 0;
+    return input === 1
+      ? `${input} ${label}`
+      : pluralLabel
+        ? `${input} ${pluralLabel}`
+        : `${input} ${label}s`;
+  }
+}

package/src/pipes/round.pipe.ts

@@ -0,0 +1,9 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({ name: 'acuteRound'  , standalone: true})
+export class RoundPipe implements PipeTransform {
+
+  transform(input: number): number {
+    return Math.round(input);
+  }
+}

package/src/pipes/time-ago-formatted.pipe.ts

@@ -0,0 +1,10 @@
+import {Pipe, PipeTransform} from '@angular/core';
+import {DurationRatchet} from "@bitblit/ratchet-common/lang/duration-ratchet";
+import {NumberRatchet} from "@bitblit/ratchet-common/lang/number-ratchet";
+
+@Pipe({ name: 'acuteTimeAgo'  , standalone: true})
+export class TimeAgoFormattedPipe implements PipeTransform {
+  transform(input: number): string {
+    return DurationRatchet.formatMsDuration(new Date().getTime() - NumberRatchet.safeNumber(input));
+  }
+}

package/src/pipes/timing.pipe.ts

@@ -0,0 +1,18 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({ name: 'acuteTiming'  , standalone: true})
+export class TimingPipe implements PipeTransform {
+  transform(time: number): string {
+    if (time) {
+      const minutes = Math.floor(time / 60);
+      const seconds = Math.floor(time % 60);
+      return `${this.initZero(minutes)}${minutes}:${this.initZero(seconds)}${seconds}`;
+    }
+
+    return '00:00';
+  }
+
+  private initZero(time: number): string {
+    return time < 10 ? '0' : '';
+  }
+}

package/src/services/google-analytics.service.spec.ts

@@ -0,0 +1,17 @@
+import { TestBed } from '@angular/core/testing';
+import { beforeEach, describe, expect, test } from 'vitest';
+
+import {GraphqlQueryService} from "./graphql-query.service";
+
+describe('GraphqlQueryService', () => {
+  let service: GraphqlQueryService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(GraphqlQueryService);
+  });
+
+  test.skip('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/services/google-analytics.service.ts

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+declare let gtag: Function;
+
+@Injectable({
+  providedIn: 'root',
+})
+// See : https://lumin8media.com/blog/add-google-analytics-angular
+export class GoogleAnalyticsService {
+  private static readonly IS_PROD: boolean = true;
+
+  constructor(private router: Router) {}
+
+  public initialize() {
+    this.onRouteChange();
+
+    // dynamically add analytics scripts to document head
+    try {
+      const url:string = 'https://www.googletagmanager.com/gtag/js?id=';
+      const gTagScript = document.createElement('script');
+      gTagScript.async = true;
+      const tagId: string = GoogleAnalyticsService.IS_PROD ? 'G-7D5BBK4K8X' : null;
+      gTagScript.src = `${url}${tagId}`;
+      document.head.appendChild(gTagScript);
+
+      const dataLayerScript = document.createElement('script');
+      dataLayerScript.innerHTML = `
+        window.dataLayer = window.dataLayer || [];
+        function gtag(){dataLayer.push(arguments);}
+        gtag('js', new Date());
+        gtag('config', '${tagId}', {'send_page_view': false});`;
+      document.head.appendChild(dataLayerScript);
+    } catch (e) {
+      Logger.error('Error adding Google Analytics', e, e);
+    }
+  }
+
+  // track visited routes
+  private onRouteChange() {
+    const tagId: string = GoogleAnalyticsService.IS_PROD ? 'G-7D5BBK4K8X' : null;
+
+    this.router.events.subscribe((event) => {
+      if (event instanceof NavigationEnd) {
+        gtag('config', tagId, {
+          page_path: event.urlAfterRedirects,
+        });
+
+        Logger.info('Sending Google Analytics tracking for: ', event.urlAfterRedirects);
+        Logger.info('Google Analytics property ID: ', tagId);
+      }
+    });
+  }
+
+  // use gtag.js to send Google Analytics Events
+  public event(action: string, eventCategory?: string, eventLabel?: string, value?: string) {
+    gtag('event', action, {
+      ...(eventCategory && { event_category: eventCategory }),
+      ...(eventLabel && { event_label: eventLabel }),
+      ...(value && { value: value }),
+    });
+  }
+}

package/src/services/graphql-query.service.spec.ts

@@ -0,0 +1,17 @@
+import { TestBed } from '@angular/core/testing';
+import { beforeEach, describe, expect, test } from 'vitest';
+
+import {GraphqlQueryService} from "./graphql-query.service";
+
+describe('GraphqlQueryService', () => {
+  let service: GraphqlQueryService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(GraphqlQueryService);
+  });
+
+  test.skip('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/services/graphql-query.service.ts

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import { DialogService } from 'primeng/dynamicdialog';
+import { MessageService } from 'primeng/api';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { GraphqlRatchet } from '@bitblit/ratchet-graphql/graphql/graphql-ratchet';
+import { BlockUiComponent } from "../components/dialogs/block-ui/block-ui.component";
+import {AuthorizationStyle} from "@bitblit/ratchet-graphql/graphql/authorization-style";
+
+@Injectable({providedIn: 'root'})
+export class GraphqlQueryService {
+  constructor(
+    private graphqlRatchet: GraphqlRatchet,
+    private dialogService: DialogService,
+    private messageService: MessageService,
+  ) {}
+
+  public async executeQuery<T>(queryName: string, variables: any,     authStyle: AuthorizationStyle = AuthorizationStyle.TokenRequired
+  ): Promise<T | null> {
+    let rval: T | null = null;
+    this.messageService.add({ severity: 'info', summary: 'Running query', detail: queryName, life: 3000 });
+
+    Logger.info('eq: %j -: %s --: %s ---: %j', queryName, variables);
+
+    try {
+      rval = await this.graphqlRatchet.executeQuery<T>(queryName, variables, authStyle);
+    } catch (err) {
+      Logger.error('Fail : %s', err);
+    } finally {
+      this.messageService.clear();
+    }
+    return rval;
+  }
+
+  public async executeQueryWithBlock<T>(
+    blockMessage: string,
+    queryName: string,
+    variables: any,
+    authStyle: AuthorizationStyle = AuthorizationStyle.TokenRequired
+  ): Promise<T | null> {
+    let rval: T | null = null;
+    this.messageService.add({ severity: 'info', summary: 'Running query', detail: queryName, life: 3000 });
+
+    Logger.info('eqb: %j -: %s --: %s ---: %j', blockMessage, queryName, variables);
+
+    try {
+      rval = await BlockUiComponent.runPromiseWithUiBlock<T>(
+        this.dialogService,
+        this.graphqlRatchet.executeQuery<T>(queryName, variables, authStyle),
+        blockMessage,
+      );
+    } catch (err) {
+      Logger.error('Fail : %s', err);
+    } finally {
+      this.messageService.clear();
+    }
+
+    return rval;
+  }
+
+
+  public async executeMutate<T>(queryName: string, variables: any,     authStyle: AuthorizationStyle = AuthorizationStyle.TokenRequired
+  ): Promise<T | null> {
+    let rval: T | null = null;
+    this.messageService.add({ severity: 'info', summary: 'Running query', detail: queryName, life: 3000 });
+
+    Logger.info('eq: %j -: %s --: %s ---: %j', queryName, variables);
+
+    try {
+      rval = await this.graphqlRatchet.executeMutate<T>(queryName, variables, authStyle);
+    } catch (err) {
+      Logger.error('Fail : %s', err);
+    } finally {
+      this.messageService.clear();
+    }
+
+    return rval;
+  }
+
+  public async executeMutateWithBlock<T>(
+    blockMessage: string,
+    queryName: string,
+    variables: any,
+    authStyle: AuthorizationStyle = AuthorizationStyle.TokenRequired
+
+  ): Promise<T | null> {
+    let rval: T | null = null;
+    this.messageService.add({ severity: 'info', summary: 'Running query', detail: queryName, life: 3000 });
+
+    try {
+      rval = await BlockUiComponent.runPromiseWithUiBlock<T>(
+        this.dialogService,
+        this.graphqlRatchet.executeMutate<T>(queryName, variables, authStyle),
+        blockMessage,
+      );
+    } catch (err) {
+      Logger.error('Fail : %s', err);
+    } finally {
+      this.messageService.clear();
+    }
+
+    return rval;
+  }
+}

package/src/services/local-storage.service.spec.ts

@@ -0,0 +1,17 @@
+import { TestBed } from '@angular/core/testing';
+import { beforeEach, describe, expect, test } from 'vitest';
+
+import {LocalStorageService} from "./local-storage.service";
+
+describe('LocalStorageService', () => {
+  let service: LocalStorageService<any>;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(LocalStorageService);
+  });
+
+  test.skip('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/services/local-storage.service.ts

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+
+
+export function storageFinder(): Storage | null {
+  if (typeof window !== 'undefined') {
+    if (typeof window.localStorage !=='undefined') {
+      return window.localStorage;
+    }
+  }
+  return null;
+}
+
+@Injectable({providedIn: 'root'})
+export class LocalStorageService<T> {
+  private static readonly APP_NAME: string = 'Scribe';
+
+  public get storageReady(): boolean {
+    return !!storageFinder();
+  }
+
+  public clear(): void {
+    this.update({ } as T );
+  }
+
+  public update(value: T): T {
+    if (this.storageReady) {
+      const toSave: T = value || ({} as T);
+      const saveString: string = JSON.stringify(toSave);
+      Logger.info('Updating storage to %s', saveString);
+      localStorage.setItem(LocalStorageService.APP_NAME, saveString);
+      return toSave;
+    } else {
+      Logger.info('Skipping update - storage not ready : %j', value);
+      return {} as T;
+    }
+  }
+
+  fetch(): T {
+    if (this.storageReady) {
+      const loadString: string = localStorage.getItem(LocalStorageService.APP_NAME) || '{}';
+      const rval: T = JSON.parse(loadString) as T;
+      return rval;
+    } else {
+      Logger.info('Skipping fetch - storage not ready');
+      return {} as T;
+    }
+  }
+
+}

package/src/services/window-ref.service.spec.ts

@@ -0,0 +1,17 @@
+import { TestBed } from '@angular/core/testing';
+import { beforeEach, describe, expect, test } from 'vitest';
+
+import {WindowRefService} from "./window-ref.service";
+
+describe('WindowRefService', () => {
+  let service: WindowRefService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(WindowRefService);
+  });
+
+  test.skip('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/services/window-ref.service.ts

@@ -0,0 +1,25 @@
+import {Injectable} from '@angular/core';
+
+// Taken from https://juristr.com/blog/2016/09/ng2-get-window-ref/
+// Here to make transition to Angular Universal later easier
+
+/* This interface is optional, showing how you can add strong typings for custom globals.
+// Just use "Window" as the type if you don't have custom global stuff
+export interface ICustomWindow extends Window {
+  __custom_global_stuff: string;
+} */
+
+function getWindow(): any {
+  if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    throw new Error('Cannot find window object - running in SSR?');
+  }
+}
+
+@Injectable({providedIn: 'root'})
+export class WindowRefService {
+  public nativeWindow(): Window {
+    return getWindow();
+  }
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "lib",
+    "rootDir": "src",
+    "stripInternal": true
+  },
+  "extends": "../../tsconfig.json",
+  "include": ["src/"]
+}