@idea-ionic/uncommon 8.2.1

package/src/offline/offlineData.service.d.ts

@@ -0,0 +1,281 @@
+import { Subscription } from 'rxjs';
+import { Delta, DeltaRecord, DeltaResources, epochDateTime } from 'idea-toolbox';
+import { IDEAStorageService, IDEATranslationsService } from '@idea-ionic/common';
+import { IDEAAWSAPIService } from '../AWSAPI.service';
+import { IDEAOfflineService } from './offline.service';
+import * as i0 from "@angular/core";
+/**
+ * After how much time we need to request a synchronisation to keep the contents up-to-date.
+ */
+export declare const SYNC_EXPIRATION_INTERVAL: number;
+/**
+ * Prefix for the key of the API requests queue info in the local storage.
+ */
+export declare const QUEUE_API_REQUESTS_KEY = "IDEAOfflineService.queueAPIrequests";
+/**
+ * Prefix for the key of the last sync time info in the local storage.
+ */
+export declare const LAST_SYNC_KEY = "IDEAOfflineService.lastSyncAt";
+/**
+ * The max number of elements per resource to synchronize during the first analysis of a synchronisation.
+ * If the number of elements exceeds (there is more data after the 1st page), the operation require manual confirmation.
+ */
+export declare const NUM_ELEMENTS_WITHOUT_MANUAL_SYNC = 100;
+/**
+ * The max number of elements per resource to request at the same time during a normal synchronisation.
+ */
+export declare const NUM_ELEMENTS_WITH_MANUAL_SYNC = 300;
+/**
+ * Manage the offline functioning of the app's data (upload/download/synchronization).
+ * Note: it includes all the methods of IDEAOfflineService.
+ *
+ * Download: it works through the **Delta** mechanism on back-end resources.
+ * Practically, the service prepares each possible API GET requests for each of the involved resources.
+ * In this way, if offline, the API service can hit an element by URL in the cache (storage offline).
+ *
+ * **How to use it**. Configure the sync mechanism in the main app.component as it follows:
+ *
+ *    1. Implement a CacheableResource class for each DeltaResource you want to cache offline.
+ *    2. Set up the service (`setUpOfflineData`).
+ *    3. Run a synchronization.
+ *    4. Add the navigation to the Offline Manager (UI).
+ *    5. Optionally, push offline API requests to the queue when offline.
+ *
+ * e.g. of CacheableResource classes:
+ * ```
+ * class CustomerCR extends CacheableResource {
+ *   constructor(description: string) {
+ *     super(DeltaResources.CUSTOMERS, description);
+ *   }
+ *   public listURL(element: any): string {
+ *     return `teams/${element.teamId}/customers`;
+ *   }
+ *   public elementURL(element: any): string {
+ *     return `teams/${element.teamId}/customers/${element.customerId}`;
+ *   }
+ *   public findIndexInList(list: Array<any>, element: any): number {
+ *     return list.findIndex(x => x.customerId === element.customerId);
+ *   }
+ *   public sort(a: any, b: any): number {
+ *     return a.name.localeCompare(b.name);
+ *   }
+ * }
+ */
+export declare class IDEAOfflineDataService {
+    protected _storage: IDEAStorageService;
+    protected _translate: IDEATranslationsService;
+    protected _offline: IDEAOfflineService;
+    protected _API: IDEAAWSAPIService;
+    /**
+     * True when running a synchronization.
+     */
+    synchronizing: boolean;
+    /**
+     * The timestamp of the last synchronization.
+     */
+    lastSyncAt: epochDateTime;
+    /**
+     * True if an error happened in the last synchronization.
+     */
+    errorInLastSync: boolean;
+    /**
+     * True if the synchronisation is too vast and so require a manual action of the user.
+     */
+    requiresManualConfirmation: boolean;
+    /**
+     * If false, ignore the entire upload scenario.
+     */
+    useQueueAPIRequests: boolean;
+    /**
+     * The array of the requests not executed because we are/were offline; they need to run once online.
+     */
+    queueAPIRequests: APIRequest[];
+    /**
+     * The id of the team of which to manage data offline.
+     * If null, the project isn't teams-based.
+     */
+    protected teamId: string;
+    /**
+     * The array of DeltaResources to cache offline.
+     */
+    protected resources: (DeltaResources | string)[];
+    /**
+     * Helper structure to manage the CacheableResource for each DeltaResource.
+     */
+    protected cacheableResources: {
+        [resource: string]: CacheableResource;
+    };
+    /**
+     * Key to acquire from the storage the lastSyncAt information of the team.
+     */
+    protected lastSyncKey: string;
+    /**
+     * Key to acquire from the storage the lastSyncAt information of the team.
+     */
+    protected queueAPIRequestKey: string;
+    constructor();
+    /**
+     * Quickly check the connection status.
+     */
+    isOnline(): boolean;
+    /**
+     * Quickly check the connection status.
+     */
+    isOffline(): boolean;
+    /**
+     * Subscribe to the service to be notified when the connection status changes.
+     */
+    subscribe(callback: (isOnline: boolean) => void): Subscription;
+    /**
+     * Quickly check for online connection.
+     */
+    check(): Promise<boolean>;
+    /**
+     * Whether the offline mode is allowed. You can customize this function, if needed.
+     */
+    isAllowed(): boolean;
+    /**
+     * Set up the service to use and sync offline data.
+     */
+    setUpOfflineData(teamId: string, useQueueAPIRequests: boolean, cacheableResources: CacheableResource[]): void;
+    /**
+     * Load from the local storage the last sync at information.
+     */
+    protected loadLastSyncAt(): Promise<number>;
+    /**
+     * Update last sync at info in the local storage.
+     */
+    protected saveLastSyncAt(lastSyncAt: number): Promise<void>;
+    /**
+     * Add a CacheableResource.
+     */
+    protected addCacheableResource(cacheableResource: CacheableResource): void;
+    /**
+     * Remove a CacheableResource by its DeltaResource.
+     */
+    protected removeCacheableResource(resource: DeltaResources | string): void;
+    /**
+     * Get the the DeltaResourced configured.
+     */
+    getResources(): (DeltaResources | string)[];
+    /**
+     * Get a CacheableResource by its DeltaResource.
+     */
+    getCacheableResource(resource: DeltaResources | string): CacheableResource;
+    /**
+     * Execute all the API requests in the queue; the requests terminated with an error will remain in the queue.
+     */
+    protected runQueueAPIRequests(): Promise<void>;
+    /**
+     * Load from the local storage the API requests queue.
+     */
+    protected loadQueueAPIRequest(): Promise<APIRequest[]>;
+    /**
+     * Update the queue in memory and also save the copy in the local storage.
+     */
+    saveQueueAPIRequest(queue?: APIRequest[]): Promise<void>;
+    /**
+     * Delete a request stuck in an error.
+     */
+    deleteRequest(request: APIRequest): Promise<never>;
+    /**
+     * Save the records of a delta and, if the latter has more pages, go recursive.
+     */
+    protected syncDeltaRecords(delta: Delta, done?: any): Promise<any>;
+    /**
+     * Save offline a list of DeltaRecords for this resource, creating a map of all the corresponding API GET requests.
+     */
+    protected syncResourceDeltaRecords(resource: string, records: DeltaRecord[]): Promise<boolean>;
+    /**
+     * Run a sync, but only if needed, i.e. the cached content expired or we have pending API requests in the queue.
+     */
+    synchronizeIfNeeded(): Promise<void>;
+    /**
+     * Synchronization of the whole set of resources (upload+download).
+     * @param manualConfirmation if true, the request comes directly from a user action (not automatic procedures).
+     */
+    synchronize(manualConfirmation?: boolean): Promise<void>;
+    /**
+     * Force a full synchronisation.
+     */
+    forceFullSync(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAOfflineDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IDEAOfflineDataService>;
+}
+/**
+ * The description of an API request to a resource, to use with `IDEAAWSAPI`.
+ * Used for queues of requests (UPLOAD).
+ */
+export interface APIRequest {
+    /**
+     * Resource path (e.g. `users` or `teams/${teamId}/users`).
+     */
+    resource: string;
+    /**
+     * The id to identify a specific element of the resource.
+     */
+    resourceId: string;
+    /**
+     * The API request method (e.g. POST, PUT, PATCH).
+     */
+    method: string;
+    /**
+     * The body of the request.
+     */
+    body: any;
+    /**
+     * A description to show for the request.
+     */
+    description?: string;
+    /**
+     * If not null, the request tried to run but it encountered the error.
+     */
+    error?: string;
+}
+/**
+ * The abstract class to implement for each resource to cache offline from the back-end (DOWNLOAD).
+ */
+export declare abstract class CacheableResource {
+    /**
+     * The team owning the resource.
+     * If null, the project isn't teams-based.
+     */
+    teamId: string;
+    /**
+     * The identifier of the resource.
+     */
+    resource: DeltaResources | string;
+    /**
+     * The resource description (translated) for the UI.
+     */
+    description: string;
+    /**
+     * Runtime attribute to know if the resource is synchronizing.
+     */
+    synchronizing: boolean;
+    /**
+     * True if one of the elements failed the execution.
+     */
+    error: boolean;
+    constructor(resource: string, description: string);
+    /**
+     * How to build the relative URL to the resource (list).
+     * E.g. `teams/${element.teamId}/customers` or `customers`.
+     */
+    abstract listURL(element: any): string;
+    /**
+     * How to build the relative URL to the resource element (detail).
+     * E.g. `teams/${element.teamId}/customers/${element.customerId}` or `customers/${element.customerId}`.
+     */
+    abstract elementURL(element: any): string;
+    /**
+     * How to uniquely identify an element in the list (by its ids).
+     * E.g. `return list.findIndex(x => x.customerId === element.customerId);`
+     */
+    abstract findIndexInList(list: any[], element: any): number;
+    /**
+     * How to keep the list sorted.
+     * E.g. `return a.name.localeCompare(b.name);`
+     */
+    abstract sort(a: any, b: any): number;
+}

package/src/offline/offlineIndicator.component.d.ts

@@ -0,0 +1,25 @@
+import { Platform } from '@ionic/angular';
+import { IDEAOfflineDataService } from './offlineData.service';
+import * as i0 from "@angular/core";
+export declare class IDEAOfflineIndicatorComponent {
+    private _alert;
+    private _modal;
+    private _translate;
+    _platform: Platform;
+    _offline: IDEAOfflineDataService;
+    /**
+     * Vertical position.
+     */
+    vertical: string;
+    /**
+     * Horizontal position.
+     */
+    horizontal: string;
+    /**
+     * Whether it is positionated on an edge.
+     */
+    edge: boolean;
+    showStatus(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAOfflineIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAOfflineIndicatorComponent, "idea-offline-indicator", never, { "vertical": { "alias": "vertical"; "required": false; }; "horizontal": { "alias": "horizontal"; "required": false; }; "edge": { "alias": "edge"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/offline/offlineManager.component.d.ts

@@ -0,0 +1,17 @@
+import { IDEAOfflineDataService, APIRequest } from './offlineData.service';
+import * as i0 from "@angular/core";
+export declare class IDEAOfflineManagerComponent {
+    private _modal;
+    private _alert;
+    private _actions;
+    private _translate;
+    _offline: IDEAOfflineDataService;
+    sync(): Promise<void>;
+    deleteRequest(request: APIRequest): Promise<void>;
+    downloadRequestLog(request: APIRequest): void;
+    actions(): Promise<void>;
+    forceFullSync(): Promise<void>;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAOfflineManagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAOfflineManagerComponent, "idea-offline-manager", never, {}, {}, never, never, false, never>;
+}

package/src/pushNotifications.service.d.ts

@@ -0,0 +1,26 @@
+import { PushNotificationSchema } from '@capacitor/push-notifications';
+import { Observable } from 'rxjs';
+import { PushNotificationsDevice } from 'idea-toolbox';
+import * as i0 from "@angular/core";
+/**
+ * To subscribe push notifications events.
+ */
+export declare class IDEAPushNotificationsService {
+    private _platform;
+    private _errorReporting;
+    registrations: Observable<PushNotificationsDevice>;
+    notifications: Observable<PushNotificationSchema>;
+    errors: Observable<Error>;
+    constructor();
+    /**
+     * Return true if the device is supported.
+     */
+    isAvailable(): boolean;
+    /**
+     * To fire the registration of a new device: it will rewquest the permission to use Push Notification.
+     * On iOS will prompt the request, on Android it's automatic.
+     */
+    registerDevice(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAPushNotificationsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IDEAPushNotificationsService>;
+}

package/src/sentiment/sentiment.component.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { Sentiment } from 'idea-toolbox';
+import { IDEAOfflineService } from '../offline/offline.service';
+import * as i0 from "@angular/core";
+export declare class IDEASentimentComponent implements OnChanges {
+    protected _env: any;
+    private _API;
+    private _translate;
+    _offline: IDEAOfflineService;
+    /**
+     * The sentiment detected from the input text.
+     */
+    sentiment: Sentiment;
+    /**
+     * The input text.
+     */
+    text: string;
+    /**
+     * Lines preferences for the item.
+     */
+    lines: string;
+    /**
+     * The color for the component.
+     */
+    color: string;
+    /**
+     * Triggers when the sentiment change.
+     */
+    change: EventEmitter<Sentiment>;
+    ngOnChanges(changes: SimpleChanges): void;
+    private detectSentiment;
+    getColorBySentiment(sentiment?: Sentiment | string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEASentimentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEASentimentComponent, "idea-sentiment", never, { "text": { "alias": "text"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "change": "change"; }, never, never, false, never>;
+}

package/src/sentiment/sentiment.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./sentiment.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@ionic/angular";
+import * as i5 from "@idea-ionic/common";
+export declare class IDEASentimentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEASentimentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IDEASentimentModule, [typeof i1.IDEASentimentComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.IonicModule, typeof i5.IDEATranslationsModule], [typeof i1.IDEASentimentComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IDEASentimentModule>;
+}

package/src/timeInterval/fromTimeToTime.component.d.ts

@@ -0,0 +1,61 @@
+import { OnInit } from '@angular/core';
+import { TimeInterval } from 'idea-toolbox';
+import * as i0 from "@angular/core";
+export declare class IDEAFromTimeToTimeComponent implements OnInit {
+    private _modal;
+    private _translate;
+    /**
+     * The time interval to set.
+     */
+    timeInterval: TimeInterval;
+    /**
+     * Whether we should start picking the time displaying the afternoon (PM) or the morning (AM, default).
+     */
+    period: Periods;
+    /**
+     * A time to use as lower limit for the possible choices.
+     */
+    notEarlierThan: number;
+    /**
+     * A time to use as upper limit for the possible choices.
+     */
+    notLaterThan: number;
+    /**
+     * The title of the component.
+     */
+    title: string;
+    segment: Segments;
+    Segments: typeof Segments;
+    Periods: typeof Periods;
+    timeIntervalWC: TimeInterval;
+    minutes: number;
+    ngOnInit(): void;
+    setInterval(hours: number, minutes?: number): void;
+    private timeToMs;
+    getClockButtonContent(hours: number, minutes?: number): string;
+    private contextualizeHour;
+    equalsFrom(hours: number, minutes?: number): boolean;
+    isAllowed(hours: number, minutes?: number): boolean;
+    isHourOfOppositeMeridian(hours: number, minutes?: number): boolean;
+    msToTimeString(time: number): string;
+    save(): void;
+    reset(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEAFromTimeToTimeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEAFromTimeToTimeComponent, "idea-from-time-to-time", never, { "timeInterval": { "alias": "timeInterval"; "required": false; }; "period": { "alias": "period"; "required": false; }; "notEarlierThan": { "alias": "notEarlierThan"; "required": false; }; "notLaterThan": { "alias": "notLaterThan"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, never, false, never>;
+}
+/**
+ * The two stages of the component, to pick the start and the end of the interval.
+ */
+declare enum Segments {
+    FROM = "FROM",
+    TO = "TO"
+}
+/**
+ * The two possible periods of the component, to interpret the clock the right way.
+ */
+export declare enum Periods {
+    AM = "AM",
+    PM = "PM"
+}
+export {};

package/src/timeInterval/timeInterval.component.d.ts

@@ -0,0 +1,84 @@
+import { EventEmitter, SimpleChanges, OnInit, OnDestroy, OnChanges } from '@angular/core';
+import { TimeInterval } from 'idea-toolbox';
+import { Periods } from './fromTimeToTime.component';
+import * as i0 from "@angular/core";
+export declare class IDEATimeIntervalComponent implements OnInit, OnDestroy, OnChanges {
+    private _modal;
+    private _translate;
+    /**
+     * The time interval to set.
+     */
+    timeInterval: TimeInterval;
+    /**
+     * Whether we should start picking the time displaying the afternoon (PM) or the morning (AM, default).
+     */
+    period: Periods;
+    /**
+     * A time to use as lower limit for the possible choices.
+     */
+    notEarlierThan: number;
+    /**
+     * A time to use as upper limit for the possible choices.
+     */
+    notLaterThan: number;
+    /**
+     * The label for the field.
+     */
+    label: string;
+    /**
+     * The icon for the field.
+     */
+    icon: string;
+    /**
+     * The color of the icon.
+     */
+    iconColor: string;
+    /**
+     * A placeholder for the field.
+     */
+    placeholder: string;
+    /**
+     * If true, the component is disabled.
+     */
+    disabled: boolean;
+    /**
+     * If true, the field has a tappable effect when disabled.
+     */
+    tappableWhenDisabled: boolean;
+    /**
+     * If true, the obligatory dot is shown.
+     */
+    obligatory: boolean;
+    /**
+     * Lines preferences for the item.
+     */
+    lines: string;
+    /**
+     * The color for the component.
+     */
+    color: string;
+    /**
+     * On select event.
+     */
+    select: EventEmitter<void>;
+    /**
+     * Icon select.
+     */
+    iconSelect: EventEmitter<void>;
+    /**
+     * On select (with the field disabled) event.
+     */
+    selectWhenDisabled: EventEmitter<void>;
+    valueToDisplay: string;
+    private langChangeSubscription;
+    isOpening: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getValueToDisplay;
+    pickTimeInterval(): Promise<void>;
+    doSelectWhenDisabled(): void;
+    doIconSelect(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEATimeIntervalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IDEATimeIntervalComponent, "idea-time-interval", never, { "timeInterval": { "alias": "timeInterval"; "required": false; }; "period": { "alias": "period"; "required": false; }; "notEarlierThan": { "alias": "notEarlierThan"; "required": false; }; "notLaterThan": { "alias": "notLaterThan"; "required": false; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tappableWhenDisabled": { "alias": "tappableWhenDisabled"; "required": false; }; "obligatory": { "alias": "obligatory"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "select": "select"; "iconSelect": "iconSelect"; "selectWhenDisabled": "selectWhenDisabled"; }, never, never, false, never>;
+}

package/src/timeInterval/timeInterval.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./fromTimeToTime.component";
+import * as i2 from "./timeInterval.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "@ionic/angular";
+import * as i6 from "@idea-ionic/common";
+export declare class IDEATimeIntervalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEATimeIntervalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IDEATimeIntervalModule, [typeof i1.IDEAFromTimeToTimeComponent, typeof i2.IDEATimeIntervalComponent], [typeof i3.CommonModule, typeof i4.FormsModule, typeof i5.IonicModule, typeof i6.IDEATranslationsModule], [typeof i1.IDEAFromTimeToTimeComponent, typeof i2.IDEATimeIntervalComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IDEATimeIntervalModule>;
+}

package/src/tinCan.service.d.ts

@@ -0,0 +1,31 @@
+import * as i0 from "@angular/core";
+/**
+ * @deprecated use a specific App service instead.
+ */
+export declare class IDEATinCanService {
+    protected data: any;
+    constructor();
+    /**
+     * Set a variable with the given value.
+     * @param variable variable to set
+     * @param value value to assign to the variable
+     */
+    set(variable: string, value: any): void;
+    /**
+     * Get the content of a variable.
+     * @param variable variable to acquire
+     * @param getAndDelete if set, delete the variable after the acquisition
+     */
+    get(variable: string, getAndDelete?: boolean): any;
+    /**
+     * Remove a variable.
+     * @param variable variable to remove
+     */
+    remove(variable: string): void;
+    /**
+     * Clear all the variables.
+     */
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IDEATinCanService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IDEATinCanService>;
+}