@dotglitch/ngx-common 1.0.2

package/services/dialog.service.d.ts

@@ -0,0 +1,41 @@
+import { MatDialog, MatDialogConfig } from '@angular/material/dialog';
+import { LazyLoaderService } from '../public-api';
+import * as i0 from "@angular/core";
+export type DialogOptions = Partial<Omit<MatDialogConfig<any>, 'data'> & {
+    /**
+     *
+     */
+    group: string;
+    /**
+     * List of properties to be provided to @Input() injectors
+     */
+    inputs: {
+        [key: string]: any;
+    };
+    /**
+     * List of properties to be provided to @Input() injectors
+     */
+    outputs: {
+        [key: string]: Function;
+    };
+    /**
+     * Context in which to execute callbacks from the `outputs` property via
+     * @Output() event Emitters
+     */
+    parent: any;
+}>;
+export declare class DialogService {
+    private dialog;
+    private lazyLoader;
+    private dialogs;
+    constructor(dialog: MatDialog, lazyLoader: LazyLoaderService);
+    open(name: string, opts?: DialogOptions): Promise<any>;
+    close(name: string): void;
+    /**
+     * Method to close _all_ dialogs.
+     * Should be used sparingly.
+     */
+    clearDialog(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
+}

package/services/fetch.service.d.ts

@@ -0,0 +1,28 @@
+import { HttpClient, HttpContext, HttpHeaders, HttpParams } from "@angular/common/http";
+import * as i0 from "@angular/core";
+export type FetchOptions = {
+    headers?: HttpHeaders | {
+        [header: string]: string | string[];
+    };
+    context?: HttpContext;
+    params?: HttpParams | {
+        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+    };
+    body?: any;
+    observe?: 'body' | 'events' | 'response';
+    reportProgress?: boolean;
+    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+    withCredentials?: boolean;
+};
+export declare class Fetch {
+    private http;
+    constructor(http: HttpClient);
+    get<T>(url: string, options?: FetchOptions, returnError?: boolean): Promise<T>;
+    put<T>(url: string, body: any, options?: FetchOptions, returnError?: boolean): Promise<T>;
+    post<T>(url: string, body: any, options?: FetchOptions, returnError?: boolean): Promise<T>;
+    patch<T>(url: string, body: any, options?: FetchOptions, returnError?: boolean): Promise<T>;
+    delete<T>(url: string, options?: FetchOptions, returnError?: boolean): Promise<T>;
+    private request;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Fetch, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Fetch>;
+}

package/services/keyboard.service.d.ts

@@ -0,0 +1,79 @@
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export type KeyCommand = {
+    /**
+     * The non-modifier key(s) that must be pressed for the event to fire.
+     */
+    key: string | string[];
+    label: string;
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    super?: boolean;
+    tab?: boolean;
+    /**
+     * Should the handler interrupt default event handling
+     */
+    interrupt?: boolean;
+};
+/**
+ * Service that listens for global keyboard events
+ */
+export declare class KeyboardService {
+    private heldKeys;
+    keyCommands: {
+        ctrl?: boolean;
+        alt?: boolean;
+        shift?: boolean;
+        super?: boolean;
+        interrupt?: boolean;
+        label: string;
+        keys: string[];
+        sub: Subject<KeyboardEvent>;
+    }[];
+    constructor();
+    private onKeyDown;
+    private onKeyUp;
+    private onKeyPress;
+    /**
+     * Use this to subscribe to keyboard events throughout
+     * the application. This is a passive listener and will
+     * **NOT** interrupt the event chain.
+     */
+    onKeyCommand(key: KeyCommand): {
+        subscribe: {
+            (observerOrNext?: Partial<import("rxjs").Observer<KeyboardEvent>> | ((value: KeyboardEvent) => void)): import("rxjs").Subscription;
+            (next?: (value: KeyboardEvent) => void, error?: (error: any) => void, complete?: () => void): import("rxjs").Subscription;
+        };
+        closed: boolean;
+        observers: import("rxjs").Observer<KeyboardEvent>[];
+        isStopped: boolean;
+        hasError: boolean;
+        thrownError: any;
+        source: import("rxjs").Observable<any>;
+        operator: import("rxjs").Operator<any, KeyboardEvent>;
+    };
+    /**
+     * Return `true` if shift is currently pressed.
+     */
+    get isShiftPressed(): boolean;
+    /**
+     * Return `true` if ctrl is currently pressed.
+     */
+    get isCtrlPressed(): boolean;
+    /**
+     * Return `true` if alt is currently pressed.
+     */
+    get isAltPressed(): boolean;
+    /**
+     * Return `true` if super (mac/linux) or the windows key is currently pressed.
+     */
+    get isSuperPressed(): boolean;
+    /**
+     * Return `true` if tab is currently pressed.
+     */
+    get isTabPressed(): boolean;
+    clearKeys(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyboardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KeyboardService>;
+}

package/types/menu.d.ts

@@ -0,0 +1,90 @@
+import { TemplateRef, Type } from '@angular/core';
+import { PopupOptions } from './popup';
+type MenuTrigger = "click" | "dblclick" | "hover" | "contextmenu";
+export type MenuOptions = Partial<PopupOptions & {
+    /**
+     * Which event should trigger the app menu.
+     */
+    trigger: MenuTrigger | MenuTrigger[];
+}>;
+type BaseMenuItem<T = any> = {
+    /**
+     * Label for the menu-item
+     */
+    label?: string;
+    /**
+     * Custom angular template to use for the label
+     * Alternatively accepts a lambda function
+     */
+    labelTemplate?: TemplateRef<any> | ((data: T) => string);
+    /**
+     * Callback method that is called when a user activates
+     * a context-menu item.
+     * Use the `contextMenuData` decorator for passing data.
+     */
+    action?: (data: T) => any;
+    /**
+     * Instead of an action, this item can be a hyperlink pointing to this URL
+     * www.example.com/foo/bar.zip
+     */
+    link?: string;
+    /**
+     * When having a configured `link` property, this specifies the `target`
+     * attribute applied to the link
+     */
+    linkTarget?: "_blank" | "_self" | "_parent" | "_top";
+    /**
+     * Custom template function for resolving a link when the context menu
+     * is opened
+     */
+    linkTemplate?: ((data: T) => string);
+    /**
+     * Callback method that is called upon a context menu activation
+     * that when it returns true, will show the item as disabled.
+     */
+    isDisabled?: (data: T) => boolean;
+    /**
+     * Callback method that is called upon a context menu activation
+     * that when returning false, will hide the menu item.
+     */
+    isVisible?: (data: T) => boolean;
+    /**
+     * If a shortcut is set, the text-label.
+     */
+    shortcutLabel?: string;
+    /**
+     * Keyboard shortcut to activate this item.
+     */
+    /**
+     * Icon to render on the left side of the item.
+     * Can be a URL/URI (must include extension)
+     * Or can be a material icon identifier.
+     */
+    icon?: string;
+    /**
+     * Optional child menu
+     */
+    children?: MenuItem<T>[];
+    /**
+     * Optional resolver that dynamically loads the contents
+     * for the menu item.
+     * Can be used to dynamically determine the submenu contents
+     */
+    childrenResolver?: (data: T) => Promise<MenuItem<T>[]>;
+    /**
+     * If `childrenResolver` is provided, disable caching of
+     * the resolved children.
+     */
+    cacheResolvedChildren?: boolean;
+    /**
+     * Instead of an array of children, render a template
+     */
+    childTemplate?: TemplateRef<T> | Type<any>;
+    /**
+     * This item is a separator.
+     * Can be used with label to make a label separator.
+     */
+    separator?: boolean;
+};
+export type MenuItem<T = any> = BaseMenuItem<T> | "separator";
+export {};

package/types/popup.d.ts

@@ -0,0 +1,27 @@
+export type PopupOptions = Partial<{
+    /**
+     * Position relative to the element the menu pops-up at
+     */
+    position: "top" | "right" | "bottom" | "left";
+    /**
+     * How the popup is aligned relative to the element
+     */
+    alignment: "center" | "beforestart" | "start" | "end" | "afterend";
+    /**
+     * @hidden
+     * WIP:
+     * Show an error from the dialog pointing to the element
+     */
+    showArrow: boolean;
+    /**
+     * @hidden
+     * WIP:
+     * Size of the arrow.
+     */
+    arrowSize: number;
+    /**
+     * How much padding to add near the edges of the screen.
+     */
+    edgePadding: number;
+    customClass: string[];
+}>;

package/utils/index.d.ts

@@ -0,0 +1,19 @@
+export declare const sleep: (ms: any) => Promise<unknown>;
+/**
+ * Prompt the user to save a json file of the given object.
+ */
+export declare const saveObjectAsFile: (name: string, data: Object) => void;
+/**
+ * Formatted logger that will print a bit of context before the message.
+ * @returns
+ */
+export declare const Logger: (context: string, contextColor: string, textColor?: string) => {
+    log: (message: any, ...args: any[]) => void;
+    warn: (message: any, ...args: any[]) => void;
+    err: (message: any, ...args: any[]) => void;
+    error: (message: any, ...args: any[]) => void;
+};
+/**
+ * Convert a string `fooBAR baz_160054''"1]"` into a slug: `foobar-baz-1600541`
+ */
+export declare const stringToSlug: (text: string) => string;