@cloudparker/moldex.js 0.0.6 → 0.0.8

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './services/utils-service.js';

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from './services/utils-service.js';

package/dist/utils/services/utils-service.d.ts

@@ -0,0 +1,72 @@
+export declare const FILE_VIEWER_HOST = "https://viewer.cloudparker.com";
+export declare const CODE_FILE_EXTENTIONS: string[];
+export declare const ACCEPT_IMAGE_FILES: string;
+export declare function random(min: number, max: number): number;
+export declare function openFilePicker(opt: {
+    accept?: string;
+    multiple?: boolean;
+}): Promise<File | File[]>;
+/**
+ * Default quality 1.0
+ * @param opt
+ * @returns
+ */
+export declare function resizeImage(opt: {
+    file: File;
+    width: number;
+    height?: number;
+    fileName?: string;
+    quality?: number;
+    type?: string;
+}): Promise<File>;
+export declare function downloadURI(uri: string, name: string): Promise<void>;
+export declare function downloadFile(file: File): Promise<void>;
+export declare function downloadBlob(blob: Blob, name: string): Promise<void>;
+export declare function fileToDataURL(file: File): Promise<string>;
+export declare function fileToText(file: File): Promise<string>;
+export declare function fileToBuffer(file: File): Promise<ArrayBuffer>;
+export declare function fileToImage(file: File): Promise<HTMLImageElement>;
+export declare function dataUrlToImage(base64: string): Promise<any>;
+export declare function stripBase64(data: string): string;
+/**
+* Function to download content from a given URL and convert it to a Base64-encoded string.
+* @param url - The URL to download the content from.
+* @returns A promise that resolves to the Base64-encoded string of the downloaded content.
+*/
+export declare function urlToBase64(url: string): Promise<string>;
+export declare function urlToFile(url: string, givenFileName?: string, givenMimeType?: string): Promise<File>;
+export declare function dataUrlToFile(url: string, givenFileName?: string, givenMimeType?: string): Promise<File>;
+export declare function bufferToFile(buffer: ArrayBuffer, filename: string, mimeType: string): Promise<File>;
+export declare function postData(url?: string, data?: {}): Promise<any>;
+export declare function fileNameAndExt(filename: string): {
+    name: string;
+    ext: string | undefined;
+};
+export declare function isValidateEmail(email: string): boolean;
+export declare function isValidURL(str: string): boolean;
+export declare function mailto({ to, body, subject }: {
+    to: string;
+    body: string;
+    subject: string;
+}): void;
+export declare function copyText(str: string): void;
+export declare function copyRichText(node: HTMLElement): void;
+export declare function download(data: string, filename: string, type: string): void;
+export declare function formatString(str: string, ...args: any[]): string;
+export declare function fileSizeString(size: number): string;
+export declare function delay(mills?: number): Promise<unknown>;
+export declare function sort<T>({ array, field, desc, isDate }: {
+    array: T[];
+    field?: string;
+    desc?: boolean;
+    isDate?: boolean;
+}): T[];
+export declare function vibrate(value?: number | number[]): void;
+export declare function playClickEffect(): void;
+export declare function toArrayByKey(key: string, obj?: any): any[];
+export declare function convertNumToAlphabates(num: number): string;
+export declare function fetchText(url: string): Promise<string>;
+export declare function isTouchDevice(): any;
+export declare function toCurrency(value?: number, symbol?: string): string;
+export declare function inchToPixel(inches: number): number;
+export declare function pixelToInch(pixels: number): number;

package/dist/utils/services/utils-service.js

@@ -0,0 +1,370 @@
+import { BROWSER } from 'esm-env';
+import { toDate } from '../../date/services/date-service.js';
+const KEY_GEO_INFO = 'geo.info';
+export const FILE_VIEWER_HOST = 'https://viewer.cloudparker.com';
+export const CODE_FILE_EXTENTIONS = [
+    "java", "js", "ts", "json", "c", "cpp", "cs", "py", "ts", "php", "rb", "swift", "go",
+    "rs", "kt", "scala", "pl", "lua", "hs", "sh", "ps1", "dart", "jl", "m", "f90", "txt",
+    "r", "groovy", "asm", "pas", "ada", "sql", "md", "html", "css", "xml", "yaml", "xml",
+    "bat",
+];
+export const ACCEPT_IMAGE_FILES = ".png,.PNG,.jpg,.jpg,.jepg,.JPEG,.webp,.WEBP";
+export function random(min, max) {
+    return min + Math.random() * (max - min);
+}
+export function openFilePicker(opt) {
+    return new Promise(resolve => {
+        let input = document.createElement('input');
+        input.type = 'file';
+        input.multiple = opt.multiple || false;
+        input.accept = opt.accept || ACCEPT_IMAGE_FILES;
+        input.onchange = _ => {
+            let files = Array.from(input.files);
+            if (opt.multiple) {
+                resolve(files);
+            }
+            else {
+                resolve(files[0]);
+            }
+            document.body.removeChild(input);
+        };
+        input.style.display = 'none';
+        document.body.appendChild(input);
+        input.click();
+    });
+}
+/**
+ * Default quality 1.0
+ * @param opt
+ * @returns
+ */
+export function resizeImage(opt) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.readAsDataURL(opt.file);
+        reader.onload = (event) => {
+            const img = new Image();
+            img.src = event.target.result;
+            img.onload = () => {
+                const elem = document.createElement('canvas');
+                let width = opt.width;
+                let height = opt.height || opt.width;
+                elem.width = width;
+                elem.height = height;
+                const ctx = elem.getContext('2d');
+                if (ctx) {
+                    ctx.drawImage(img, 0, 0, width, height);
+                    ctx.canvas.toBlob((blob) => {
+                        const f = new File([blob], opt.fileName || opt.file
+                            .name, {
+                            type: opt.type || 'image/webp',
+                            lastModified: Date.now()
+                        });
+                        resolve(f);
+                    }, opt.type || 'image/webp', opt.quality ? (opt.quality / 100) : 0.8);
+                }
+            },
+                reader.onerror = error => console.log(error);
+        };
+    });
+}
+export async function downloadURI(uri, name) {
+    const res = await fetch(uri);
+    const link = document.createElement("a");
+    link.download = name;
+    link.href = URL.createObjectURL(await res.blob());
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+}
+export async function downloadFile(file) {
+    const link = document.createElement("a");
+    link.download = file.name;
+    link.href = URL.createObjectURL(file);
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+}
+export function downloadBlob(blob, name) {
+    return downloadFile(new File([blob], name));
+}
+export async function fileToDataURL(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = function () {
+            const base64data = reader.result;
+            //console.log(base64data);
+            resolve(base64data);
+        };
+        reader.readAsDataURL(file);
+    });
+}
+export async function fileToText(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = function () {
+            const text = reader.result;
+            //console.log(base64data);
+            resolve(text);
+        };
+        reader.readAsText(file);
+    });
+}
+export async function fileToBuffer(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = function () {
+            resolve(reader.result);
+        };
+        reader.readAsArrayBuffer(file);
+    });
+}
+export async function fileToImage(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => {
+            var imgObj = new Image();
+            imgObj.src = reader.result;
+            imgObj.onload = () => {
+                resolve(imgObj);
+            };
+        };
+        reader.readAsDataURL(file);
+    });
+}
+export async function dataUrlToImage(base64) {
+    return new Promise((resolve, reject) => {
+        var imgObj = new Image();
+        imgObj.src = base64;
+        imgObj.onload = () => {
+            resolve(imgObj);
+        };
+    });
+}
+export function stripBase64(data) {
+    if (data) {
+        return data.split(',')[1];
+    }
+    return data;
+}
+/**
+* Function to download content from a given URL and convert it to a Base64-encoded string.
+* @param url - The URL to download the content from.
+* @returns A promise that resolves to the Base64-encoded string of the downloaded content.
+*/
+export async function urlToBase64(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch: ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const base64Content = btoa(new Uint8Array(arrayBuffer)
+            .reduce((data, byte) => data + String.fromCharCode(byte), ''));
+        return base64Content;
+    }
+    catch (error) {
+        console.error('Error downloading or converting content:', error);
+        throw error;
+    }
+}
+export function urlToFile(url, givenFileName, givenMimeType) {
+    return dataUrlToFile(url, givenFileName, givenMimeType);
+}
+export function dataUrlToFile(url, givenFileName, givenMimeType) {
+    return (fetch(url)
+        .then(async (res) => {
+        // Get Content-Disposition header and extract filename
+        const contentDisposition = res.headers.get('Content-Disposition');
+        let fileName = "";
+        if (contentDisposition) {
+            const filenameMatch = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/);
+            if (filenameMatch && filenameMatch[1]) {
+                fileName = filenameMatch[1].replace(/['"]/g, '');
+            }
+        }
+        // Get Content-Type header (MIME type)
+        const mimeType = res.headers.get('Content-Type') || '';
+        const buffer = await res.arrayBuffer();
+        return { buffer, fileName, mimeType };
+    })
+        .then(({ buffer, fileName, mimeType }) => {
+        return new File([buffer], givenFileName || fileName, {
+            type: givenMimeType || mimeType
+        });
+    }));
+}
+export async function bufferToFile(buffer, filename, mimeType) {
+    return new File([buffer], filename, {
+        type: mimeType
+    });
+}
+export async function postData(url = '', data = {}) {
+    // Default options are marked with *
+    const response = await fetch(url, {
+        method: 'POST', // *GET, POST, PUT, DELETE, etc.
+        mode: 'cors', // no-cors, *cors, same-origin
+        cache: 'no-cache', // *default, no-cache, reload, force-cache, only-if-cached
+        credentials: 'same-origin', // include, *same-origin, omit
+        headers: {
+            'Content-Type': 'application/json'
+            // 'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        redirect: 'follow', // manual, *follow, error
+        referrerPolicy: 'no-referrer', // no-referrer, *no-referrer-when-downgrade, origin, origin-when-cross-origin, same-origin, strict-origin, strict-origin-when-cross-origin, unsafe-url
+        body: JSON.stringify(data) // body data type must match "Content-Type" header
+    });
+    return response.json(); // parses JSON response into native JavaScript objects
+}
+export function fileNameAndExt(filename) {
+    let arr = (filename || '').split('.');
+    let ext = arr.pop();
+    let name = arr.join('.');
+    return { name, ext };
+}
+export function isValidateEmail(email) {
+    const reg = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+    return reg.test(String(email).toLowerCase());
+}
+export function isValidURL(str) {
+    var pattern = new RegExp('^(https?:\\/\\/)?' + // protocol
+        '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
+        '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
+        '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
+        '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
+        '(\\#[-a-z\\d_]*)?$', 'i'); // fragment locator
+    return !!pattern.test(str);
+}
+export function mailto({ to, body = '', subject = '' }) {
+    var uri = `mailto:${to || ''}?subject=${encodeURIComponent(subject || '')}&body=${encodeURIComponent(body || '')}`;
+    window.open(uri);
+}
+export function copyText(str) {
+    const el = document.createElement('textarea');
+    el.value = str;
+    el.setAttribute('readonly', '');
+    el.style.position = 'absolute';
+    el.style.left = '-9999px';
+    document.body.appendChild(el);
+    el.select();
+    el.setSelectionRange(0, 99999); /* For mobile devices */
+    if (navigator.clipboard) {
+        navigator.clipboard.writeText(str);
+    }
+    else {
+        document.execCommand('copy', false);
+    }
+    document.body.removeChild(el);
+}
+;
+export function copyRichText(node) {
+    if (BROWSER) {
+        let r = document.createRange();
+        r.selectNode(node);
+        window.getSelection().removeAllRanges();
+        window.getSelection().addRange(r);
+        document.execCommand("copy");
+        window.getSelection().removeAllRanges();
+    }
+}
+export function download(data, filename, type) {
+    const blob = new Blob([data], { type: type || 'application/octet-stream' });
+    const elem = window.document.createElement('a');
+    elem.href = window.URL.createObjectURL(blob);
+    elem.download = filename;
+    document.body.appendChild(elem);
+    elem.click();
+    document.body.removeChild(elem);
+}
+export function formatString(str, ...args) {
+    var formatted = str;
+    for (var i = 0; i < args.length; i++) {
+        var regexp = new RegExp('\\{' + i + '\\}', 'gi');
+        formatted = formatted.replace(regexp, args[i]);
+    }
+    return formatted;
+}
+export function fileSizeString(size) {
+    var i = size == 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
+    return parseInt((size / Math.pow(1024, i)).toFixed(2)) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][i];
+}
+export function delay(mills = 0) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, mills);
+    });
+}
+export function sort({ array, field, desc, isDate }) {
+    return array.sort((a, b) => {
+        let valA = typeof a === 'object' && field ? a[field] : a;
+        let valB = typeof b === 'object' && field ? b[field] : b;
+        if (isDate) {
+            valA = toDate(valA);
+            valB = toDate(valB);
+        }
+        else {
+            // Case-insensitive string comparison
+            if (typeof valA === 'string')
+                valA = valA.toLowerCase();
+            if (typeof valB === 'string')
+                valB = valB.toLowerCase();
+        }
+        if (valA < valB) {
+            return desc ? 1 : -1;
+        }
+        else if (valA > valB) {
+            return desc ? -1 : 1;
+        }
+        return 0;
+    });
+}
+export function vibrate(value = 20) {
+    if (window?.navigator?.vibrate) {
+        window.navigator.vibrate(value);
+    }
+}
+export function playClickEffect() {
+    vibrate();
+}
+export function toArrayByKey(key, obj = {}) {
+    return Object.keys(obj).map((k) => {
+        let data = obj[k];
+        if (data) {
+            data[key] = k;
+        }
+        return data;
+    }).filter(o => o) || [];
+}
+export function convertNumToAlphabates(num) {
+    let alphabates = 'abcdefghij'.split('');
+    let numArray = num.toString().split('').map((o) => parseInt(o));
+    return numArray.map((i) => alphabates[i]).join('');
+}
+export async function fetchText(url) {
+    const response = await fetch(url);
+    let text = await response.text();
+    // console.log(text)
+    return text;
+}
+export function isTouchDevice() {
+    return 'ontouchstart' in window || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 || window.matchMedia("(pointer: coarse)").matches;
+}
+export function toCurrency(value = 0, symbol = '$') {
+    let currency = Math.abs(value);
+    let result = '';
+    if (value < 0) {
+        result += '- ';
+    }
+    if (symbol) {
+        result += `${symbol} `;
+    }
+    result += currency.toFixed(2);
+    return result;
+}
+export function inchToPixel(inches) {
+    return inches * 96; // DPI
+}
+export function pixelToInch(pixels) {
+    return pixels / 96; // DPI
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudparker/moldex.js",
-    "version": "0.0.6",
+    "version": "0.0.8",
     "author": "cloudparker.com",
     "license": "MIT",
     "keywords": [
@@ -27,6 +27,8 @@
     "repository": "https://github.com/paramanandapradhan/moldex.js",
     "homepage": "https://cloudparker.com",
     "devDependencies": {
-        "@sveltejs/kit": "^2.0.0"
+        "@cloudparker/easy-script-loader-svelte": "^3.0.3",
+        "esm-env": "^1.0.0",
+        "moment": "^2.30.1"
     }
 }

package/dist/common/index.d.ts

@@ -1,5 +0,0 @@
-import Drawer from './components/drawer/drawer.svelte';
-import Navbar from './components/navbar/navbar.svelte';
-import Spinner from './components/spinner/spinner.svelte';
-import VerticalRule from './components/vertical-rule/verticcal-rule.svelte';
-export { Drawer, Navbar, Spinner, VerticalRule };

package/dist/common/index.js

@@ -1,5 +0,0 @@
-import Drawer from './components/drawer/drawer.svelte';
-import Navbar from './components/navbar/navbar.svelte';
-import Spinner from './components/spinner/spinner.svelte';
-import VerticalRule from './components/vertical-rule/verticcal-rule.svelte';
-export { Drawer, Navbar, Spinner, VerticalRule };