quasar-ui-danx 0.2.4 → 0.2.6

package/dist/helpers/FileUpload.d.ts

@@ -0,0 +1,107 @@
+export type FileUploadOptions = {
+    directory: string;
+    presignedUploadUrl: (...params: any) => "";
+    uploadCompletedUrl: (...params: any) => "";
+};
+export type UploadedFile = {
+    id: string;
+    name: string;
+    size: number;
+    type: string;
+    progress: number;
+    location: string;
+    blobUrl: string;
+};
+export declare class FileUpload {
+    files: UploadedFile[];
+    fileUploads: never[];
+    onErrorCb: null;
+    onProgressCb: null;
+    onCompleteCb: null;
+    onAllCompleteCb: null;
+    options: FileUploadOptions | {};
+    constructor(files: UploadedFile[] | UploadedFile, options?: FileUploadOptions | {});
+    /**
+     * Prepares all files for upload and provides an id and blobUrl for each file
+     */
+    prepare(): void;
+    /**
+     * Callback for when all files have been uploaded
+     */
+    onAllComplete(cb: any): this;
+    /**
+     * Callback fired once for each file upon successful completion of upload
+     * @param cb
+     * @returns {FileUpload}
+     */
+    onComplete(cb: any): this;
+    /**
+     * Callback fired each time there is an upload progress update for a file
+     * @param cb
+     * @returns {FileUpload}
+     */
+    onProgress(cb: any): this;
+    /**
+     * Callback fired when an error occurs during upload
+     * @param cb
+     * @returns {FileUpload}
+     */
+    onError(cb: any): this;
+    /**
+     * Handles the error events / fires the callback if it is set
+     * @param e
+     * @param file
+     * @param error
+     */
+    errorHandler(e: any, file: any, error?: null): void;
+    /**
+     * Resolve the locations of all the files
+     * @returns {Promise<FileUpload>}
+     */
+    resolveLocation(waitMessage?: null): Promise<this>;
+    /**
+     * Fires the progress callback
+     * @param fileUpload
+     * @param progress
+     */
+    fireProgressCallback(fileUpload: any, progress: any): void;
+    /**
+     * Fires the complete callback
+     * @param fileUpload
+     * @param uploadedFile
+     */
+    fireCompleteCallback(fileUpload: any, uploadedFile: any): void;
+    /**
+     * Check if all files have been uploaded and call the callback if they have
+     */
+    checkAllComplete(): void;
+    /**
+     * Returns a native JS object that is easier to work with than the File objects (no weird behavior of missing
+     * properties, easily printable, etc.)
+     * @param file
+     * @returns {{size, name, progress, location, blobUrl: *, id, type}}
+     */
+    wrapFile(file: any): {
+        id: any;
+        name: any;
+        size: any;
+        type: any;
+        progress: any;
+        location: any;
+        blobUrl: any;
+    };
+    /**
+     * Registers all the callbacks requested for the XHR / post-processing of file uploads
+     */
+    setXhrCallbacks(): void;
+    /**
+     * Mark the presigned upload as completed and return the file resource from the platform server
+     * @param fileUpload
+     * @returns {Promise<void>}
+     */
+    completePresignedUpload(fileUpload: any): Promise<any>;
+    /**
+     * Start uploading all files
+     */
+    upload(): Promise<void>;
+}

package/dist/helpers/FlashMessages.d.ts

@@ -0,0 +1,24 @@
+export declare class FlashMessages {
+    static notify: any;
+    static PROP_DEFINITIONS: {
+        successMsg: {
+            type: StringConstructor;
+            default: string;
+        };
+        errorMsg: {
+            type: StringConstructor;
+            default: string;
+        };
+        warningMsg: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    static enable(msgProps: any): void;
+    static send(message: any, options?: {}): void;
+    static success(message: any, options?: {}): void;
+    static error(message: any, options?: {}): void;
+    static warning(message: any, options?: {}): void;
+    static combine(type: any, messages: any, options?: {}): void;
+}
+export declare const notify: FlashMessages;

package/dist/helpers/actions.d.ts

@@ -0,0 +1,58 @@
+import { VNode } from 'vue';
+
+interface ActionOptions {
+    name?: string;
+    label?: string;
+    menu?: boolean;
+    batch?: boolean;
+    category?: string;
+    class?: string;
+    trigger?: (target: object[] | object, input: any) => Promise<any>;
+    activeTarget?: any;
+    vnode?: (target: object[] | object) => VNode;
+    enabled?: (target: object) => boolean;
+    batchEnabled?: (targets: object[]) => boolean;
+    optimistic?: (action: ActionOptions, target: object, input: any) => void;
+    onAction?: (action: string | null, target: object, input: any) => Promise<any>;
+    onBatchAction?: (action: string | null, targets: object[], input: any) => Promise<any>;
+    onStart?: (action: ActionOptions | null, targets: object, input: any) => boolean;
+    onSuccess?: (action: string | null, targets: object, input: any) => any;
+    onError?: (action: string | null, targets: object, input: any) => any;
+    onFinish?: (action: string | null, targets: object, input: any) => any;
+}
+export declare const activeActionVnode: import('vue').ShallowRef<null>;
+/**
+ * Hook to perform an action on a set of targets
+ * This helper allows you to perform actions by name on a set of targets using a provided list of actions
+ *
+ * @param actions
+ * @param {ActionOptions} globalOptions
+ */
+export declare function useActions(actions: ActionOptions[], globalOptions?: ActionOptions): {
+    actions: {
+        name?: string | undefined;
+        label?: string | undefined;
+        menu?: boolean | undefined;
+        batch?: boolean | undefined;
+        category?: string | undefined;
+        class?: string | undefined;
+        trigger?: ((target: object | object[], input: any) => Promise<any>) | undefined;
+        activeTarget?: any;
+        vnode?: ((target: object | object[]) => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+            [key: string]: any;
+        }>) | undefined;
+        enabled?: ((target: object) => boolean) | undefined;
+        batchEnabled?: ((targets: object[]) => boolean) | undefined;
+        optimistic?: ((action: ActionOptions, target: object, input: any) => void) | undefined;
+        onAction?: ((action: string | null, target: object, input: any) => Promise<any>) | undefined;
+        onBatchAction?: ((action: string | null, targets: object[], input: any) => Promise<any>) | undefined;
+        onStart?: ((action: ActionOptions | null, targets: object, input: any) => boolean) | undefined;
+        onSuccess?: ((action: string | null, targets: object, input: any) => any) | undefined;
+        onError?: ((action: string | null, targets: object, input: any) => any) | undefined;
+        onFinish?: ((action: string | null, targets: object, input: any) => any) | undefined;
+    }[];
+    isSavingTarget: (target: any) => boolean;
+    filterActions: (filters: object) => ActionOptions[];
+    performAction: (name: string | object, target: object[] | object, input?: any) => Promise<any>;
+};
+export {};

package/dist/helpers/array.d.ts

@@ -0,0 +1,16 @@
+/**
+ *
+ * @param array
+ * @param item
+ * @param newItem
+ * @returns {*[]}
+ */
+export declare function replace(array: any, item: any, newItem?: undefined): any[];
+export declare function remove(array: any, item: any): any[];
+/**
+ * Remove duplicate items from an array using a callback to compare 2 elements
+ * @param array
+ * @param cb
+ * @returns {*}
+ */
+export declare function uniqueBy(array: any, cb: any): any;

package/dist/helpers/compatibility.d.ts

@@ -0,0 +1,8 @@
+export declare function useCompatibility(requestLocation?: boolean): {
+    isLocationSupported: boolean;
+    isCompatible: import('vue').ComputedRef<boolean>;
+    geolocationError: null;
+    hasLocation: null;
+    location: import('vue').ComputedRef<any>;
+    waitForLocation: (maxWait?: number) => Promise<import('vue').ComputedRef<any> | null>;
+};

package/dist/helpers/date.d.ts

@@ -0,0 +1 @@
+export declare function diffInDays(date1: any, date2: any): any;

package/dist/helpers/download.d.ts

@@ -0,0 +1 @@
+export declare function download(data: any, strFileName: any, strMimeType: any): any;

package/dist/helpers/downloadPdf.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Asynchronously load a file from the URL and trigger a download in the browser
+ *
+ * @param url
+ * @param filename
+ * @param postParams
+ * @returns {Promise<void>}
+ */
+export declare function downloadFile(url: any, filename?: string, postParams?: null): Promise<void>;
+/**
+ * Downloads a file from a response object w/ a file attachment
+ *
+ * @param response
+ * @param filename
+ */
+export declare function downloadFileResponse(response: any, filename?: string): Promise<void>;
+/**
+ * Get a header from a response object
+ * @param response
+ * @param header
+ * @param defaultValue
+ * @returns {*}
+ */
+export declare function getResponseHeader(response: any, header: any, defaultValue: any): any;

package/dist/helpers/files.d.ts

@@ -0,0 +1 @@
+export declare function resolveFileLocation(file: any, waitMessage?: null): Promise<any>;

package/dist/helpers/formats.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Converts a date string from the server's time zone to the user's time zone.
+ * @param {String} dateTimeString
+ * @returns {DateTime}
+ */
+export declare function localizedDateTime(dateTimeString: any): any;
+/**
+ * Converts a date string from the user's time zone to the server's time zone.
+ * @param dateTimeString
+ * @returns {DateTime}
+ */
+export declare function remoteDateTime(dateTimeString: any): any;
+/**
+ * @param {DateTime|String} dateTime
+ * @returns {DateTime|*}
+ */
+export declare function parseDateTime(dateTime: any): any;
+/**
+ * Parses a Quasar formatted date string into a Luxon DateTime object
+ * @param date
+ * @param format
+ * @returns {DateTime}
+ */
+export declare function parseQDate(date: any, format?: string): any;
+/**
+ * Parses a Quasar formatted date/time string into a Luxon DateTime object
+ * @param date
+ * @param format
+ * @returns {DateTime}
+ */
+export declare function parseQDateTime(date: any, format?: string): any;
+/**
+ * Formats a Luxon DateTime object into a Quasar formatted date string
+ * @param date
+ * @returns {string}
+ */
+export declare function fQDate(date: any): any;
+/**
+ *
+ * @param {String} dateTimeString
+ * @param options
+ * @returns {string}
+ */
+export declare function fLocalizedDateTime(dateTimeString: any, options?: {}): any;
+/**
+ * Formats a date/time object or string into a human-readable format
+ *
+ * @param {String|Object} dateTime
+ * @param format
+ * @param {String|null} empty
+ * @returns {string}
+ */
+export declare function fDateTime(dateTime?: null, { format, empty }?: {
+    format?: string | undefined;
+    empty?: string | undefined;
+}): any;
+/**
+ * Formats a date/time object or string into the best format for DB input
+ * @param dateTime
+ * @returns {string}
+ */
+export declare function dbDateTime(dateTime?: null): any;
+/**
+ * Formats a date object or string into a human-readable format
+ * @param {String|Object} dateTime
+ * @param {String|null} empty
+ * @param format
+ * @returns {string}
+ */
+export declare function fDate(dateTime: any, { empty, format }?: {
+    empty?: string | undefined;
+    format?: string | undefined;
+}): any;
+/**
+ * Formats a number of seconds into Hours / Minutes / Seconds or just Minutes and Seconds
+ *
+ * @param second
+ * @returns {string}
+ */
+export declare function fSecondsToTime(second: any): string;
+/**
+ * Formats an amount into USD currency format
+ * @param amount
+ * @returns {string}
+ */
+export declare function fCurrency(amount: any): string;
+/**
+ * Formats a number into a human-readable format
+ * @param number
+ * @param options
+ * @returns {string}
+ */
+export declare function fNumber(number: any, options?: {}): string;
+/**
+ * Truncates the string by removing chars from the middle of the string
+ * @param str
+ * @param maxLength
+ * @returns {string|*}
+ */
+export declare function centerTruncate(str: any, maxLength: any): any;
+/**
+ * Formats a number into a percentage
+ * @param num
+ * @param options
+ * @returns {string}
+ */
+export declare function fPercent(num: any, options?: {
+    multiplier: number;
+    maximumFractionDigits: number;
+    NaN: string;
+}): string;
+export declare function fPhone(value: any): any;

package/dist/helpers/http.d.ts

@@ -0,0 +1,23 @@
+export declare const request: {
+    get(url: any, options?: {}): Promise<any>;
+    post(url: any, data?: {}, options?: {}): Promise<any>;
+};
+/**
+ * Fetches a resource list applying the filter. If there is a selected resource,
+ * stores that resource from the already populated list. If that resource does not exist
+ * also fetches that resource record from the endpoint, then adds it to the list if it
+ * does not exist in the filtered list
+ *
+ * @param fetchFn
+ * @param list
+ * @param id
+ * @param filter
+ * @returns {Promise<void>}
+ */
+export declare function fetchResourceListWithSelected(fetchFn: any, list: any, id: any, filter: any): Promise<void>;
+/**
+ * Returns the value of the URL parameter (if it is set)
+ * @param key
+ * @param url
+ */
+export declare function getUrlParam(key: any, url?: undefined): string | null;

package/dist/helpers/index.d.ts

@@ -0,0 +1,15 @@
+export * from './array';
+export * from './compatibility';
+export * from './date';
+export * from './download';
+export * from './downloadPdf';
+export * from './files';
+export * from './FileUpload';
+export * from './FlashMessages';
+export * from './formats';
+export * from './http';
+export * from './multiFileUpload';
+export * from './actions';
+export * from './singleFileUpload';
+export * from './storage';
+export * from './utils';

package/dist/helpers/multiFileUpload.d.ts

@@ -0,0 +1,11 @@
+import { FileUploadOptions } from './FileUpload';
+
+export declare function useMultiFileUpload(options: FileUploadOptions): {
+    onClear: () => void;
+    onRemove: (file: any) => void;
+    onComplete: (cb: any) => void;
+    onFilesChange: (cb: any) => void;
+    onDrop: (e: any) => void;
+    onFilesSelected: (e: any) => void;
+    uploadedFiles: import('vue').Ref<never[]>;
+};

package/dist/helpers/singleFileUpload.d.ts

@@ -0,0 +1,11 @@
+import { FileUploadOptions } from './FileUpload';
+
+export declare function useSingleFileUpload(options?: FileUploadOptions): {
+    isFileUploaded: import('vue').ComputedRef<null>;
+    onClear: () => void;
+    onComplete: (cb: any) => void;
+    onFileChange: (cb: any) => void;
+    onDrop: (e: any) => void;
+    onFileSelected: (e: any) => void;
+    uploadedFile: import('vue').Ref<null>;
+};

package/dist/helpers/storage.d.ts

@@ -0,0 +1,2 @@
+export declare function setItem(key: any, value: any): void;
+export declare function getItem(key: any, defaultValue?: null): any;

package/dist/helpers/utils.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Sleep function to be used in conjuction with async await:
+ *
+ * eg: await sleep(5000);
+ *
+ * @param delay
+ * @returns {Promise<any>}
+ */
+export declare function sleep(delay: any): Promise<unknown>;
+/**
+ * Wait for a ref to have a value and then resolve the promise
+ *
+ * @param ref
+ * @param value
+ * @returns {Promise<void>}
+ */
+export declare function waitForRef(ref: any, value: any): Promise<void>;
+/**
+ * Returns a number that is constrained to the given range.
+ * @param min
+ * @param max
+ * @param value
+ * @returns {number}
+ */
+export declare function minmax(min: any, max: any, value: any): number;
+/**
+ * Convert meters to miles
+ * @param meters
+ * @returns {number}
+ */
+export declare function metersToMiles(meters: any): number;
+/**
+ * Convert miles to meters
+ * @param miles
+ * @returns {number}
+ */
+export declare function milesToMeters(miles: any): number;
+/**
+ * Parses a string for Lat and Long coords
+ * @param location
+ * @returns {null|{lng: number, lat: number}}
+ */
+export declare function parseCoords(location: any): {
+    lat: number;
+    lng: number;
+} | null;

package/dist/svg/index.d.ts

@@ -0,0 +1,12 @@
+export { default as CaretDownIcon } from './CaretDownIcon.svg';
+export { default as DragHandleDotsIcon } from './DragHandleDotsIcon.svg';
+export { default as DragHandleIcon } from './DragHandleIcon.svg';
+export { default as FilterIcon } from './FilterIcon.svg';
+export { default as ImageIcon } from './ImageIcon.svg';
+export { default as PdfIcon } from './PdfIcon.svg';
+export { default as PercentIcon } from './PercentIcon.svg';
+export { default as SkipNextIcon } from './SkipNextIcon.svg';
+export { default as SkipPreviousIcon } from './SkipPreviousIcon.svg';
+export { default as TrashIcon } from './TrashIcon.svg';
+export { default as WarningIcon } from './WarningIcon.svg';
+export { default as XIcon } from './XIcon.svg';

package/dist/vendor/tinymce-config.d.ts

@@ -0,0 +1 @@
+export declare const apiKey = "YOUR_API_KEY";

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "quasar-ui-danx",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "author": "Dan <dan@flytedesk.com>",
   "description": "DanX Vue / Quasar component library",
   "license": "MIT",
   "type": "module",
-  "main": "dist/dan.es.js",
-  "module": "dist/dan.es.js",
+  "main": "dist/danx.es.js",
+  "module": "dist/danx.es.js",
   "scripts": {
-    "dev": "vite",
+    "dev": "cd dev && quasar dev && cd ..",
     "build": "vite build",
     "preview": "vite preview"
   },
@@ -32,8 +32,9 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.4.4",
     "vite": "^5.2.8",
+    "vite-plugin-dts": "^3.8.1",
     "vite-svg-loader": "^5.1.0",
-    "vue": "^3.0.0",
+    "vue": "^3.4.21",
     "vue-router": "^4.0.0"
   },
   "dependencies": {

package/src/helpers/FileUpload.ts

@@ -4,21 +4,31 @@ import { resolveFileLocation } from "./files";
 import { FlashMessages } from "./FlashMessages";
 
 export type FileUploadOptions = {
-    directory: string,
-    presignedUploadUrl: (...params) => "",
-    uploadCompletedUrl: (...params) => "",
+    directory?: string,
+    presignedUploadUrl?: (...params: any) => "",
+    uploadCompletedUrl?: (...params: any) => "",
 };
 
+export type UploadedFile = {
+    id: string,
+    name: string,
+    size: number,
+    type: string,
+    progress: number,
+    location: string,
+    blobUrl: string
+}
+
 export class FileUpload {
-    files: { id: string, blobUrl: string }[] = [];
+    files: UploadedFile[] = [];
     fileUploads = [];
     onErrorCb = null;
     onProgressCb = null;
     onCompleteCb = null;
     onAllCompleteCb = null;
-    options: FileUploadOptions = null;
+    options: FileUploadOptions = {};
 
-    constructor(files, options: FileUploadOptions = null) {
+    constructor(files: UploadedFile[] | UploadedFile, options: FileUploadOptions = {}) {
         if (!Array.isArray(files) && !(files instanceof FileList)) {
             files = [files];
         }
@@ -31,7 +41,6 @@ export class FileUpload {
 
         this.options = {
             ...danxOptions.fileUpload,
-            ...this.options,
             ...options
         };
 

package/tsconfig.json

@@ -1,32 +1,41 @@
 {
   "compilerOptions": {
-    "outDir": "./dist",
-    "declaration": true,
-    // Specify ECMAScript target version
+    // Compile down to ESNext (or choose your target version)
     "target": "esnext",
-    // Specify module code generation
+    // Use ES modules
     "module": "esnext",
+    // Library files to be included in the compilation
+    "lib": [
+      "dom",
+      "esnext"
+    ],
+    // Generate corresponding '.d.ts' file
+    "declaration": true,
+    // Output directory for the compiled files
+    "outDir": "./dist",
+    // Root directory of your source files
+    "rootDir": "./src",
     // Enable all strict type-checking options
-    "strict": false,
-    // Enables compatibility with Babel-imported CommonJS modules
+    "strict": true,
+    // Enables compatibility with Babel-style module imports
     "esModuleInterop": true,
-    "resolveJsonModule": true,
+    // Skip type checking of all declaration files (*.d.ts)
+    "skipLibCheck": true,
+    // Disallow inconsistently-cased references to the same file
+    "forceConsistentCasingInFileNames": true,
     // Resolve modules using Node.js style
     "moduleResolution": "node",
     // Allow default imports from modules with no default export
     "allowSyntheticDefaultImports": true,
     // Enables experimental support for decorators
     "experimentalDecorators": true,
-    // Skip type checking of all declaration files (*.d.ts)
-    "skipLibCheck": true,
+    // Enables source map generation for the compiled files (useful for debugging)
     "sourceMap": true,
-    // Disallow inconsistently-cased references to the same file.
-    "forceConsistentCasingInFileNames": true,
     // Base directory to resolve non-relative module names,
     "baseUrl": "./",
     "paths": {
       "@/*": [
-        "./dev/src/*"
+        "./src/*"
       ]
     }
   },
@@ -38,6 +47,8 @@
   ],
   "exclude": [
     "node_modules",
-    "dist"
+    "dist",
+    "demo",
+    "**/*.spec.ts"
   ]
 }

package/vite.config.js

@@ -1,10 +1,16 @@
 import vue from '@vitejs/plugin-vue';
 import { resolve } from 'path';
 import { defineConfig } from 'vite';
+import dts from 'vite-plugin-dts';
 import svgLoader from 'vite-svg-loader';
 
 export default defineConfig({
-    plugins: [vue(), svgLoader()],
+    plugins: [vue(), svgLoader(), dts({
+        compilerOptions: {
+            noImplicitAny: false,
+            suppressImplicitAnyIndexErrors: true
+        }
+    })],
     resolve: {
         extensions: ['.mjs', '.js', '.ts', '.mts', '.jsx', '.tsx', '.json', '.vue', '.svg']
     },