@fajarmaulana/komerce-lp-helper 0.1.0

package/dist/utils/file.d.ts

@@ -0,0 +1,95 @@
+interface ICheckImage {
+    (url: string): Promise<string>;
+}
+interface IConvertBlob {
+    (blob: Blob): Promise<string>;
+}
+interface ICreateDownloadAnchor {
+    (blob: Blob, options?: {
+        filename?: string;
+        target?: string;
+    }): {
+        anchor: HTMLAnchorElement;
+        blobUrl: string;
+    };
+}
+interface IDownloadBlob {
+    (blob: Blob, filename: string): void;
+}
+/**
+ * Check if an image URL is valid by attempting to load it.
+ *
+ * @param url - The image URL to check.
+ */
+export declare const checkImage: ICheckImage;
+/**
+ * Converts a Blob object into a Base64-encoded data URL string.
+ *
+ * @param blob - The Blob object to be converted.
+ * @returns - A Promise that resolves to a Base64-encoded data URL string.
+ */
+export declare const convertBlob: IConvertBlob;
+/**
+ * Gets the file extension suggestion based on MIME type
+ *
+ * @param mimeType - The MIME type string
+ * @returns Suggested file extension (without dot)
+ *
+ * @example
+ * ```ts
+ * const ext = getExtension('application/pdf')
+ * console.log(ext) // 'pdf'
+ * ```
+ */
+export declare function getExtension(mimeType: string): string;
+/**
+ * Generates a suggested filename from a Blob based on its MIME type
+ *
+ * @param blob - The Blob to generate filename for
+ * @param prefix - Optional prefix for the filename (default: 'download')
+ * @returns Suggested filename with extension
+ *
+ * @example
+ * ```ts
+ * const blob = new Blob(['data'], { type: 'application/pdf' })
+ * const filename = filenameWithExtension(blob)
+ * console.log(filename) // 'download.pdf'
+ * ```
+ */
+export declare function filenameWithExtension(blob: Blob, prefix?: string): string;
+/**
+ * Creates an HTMLAnchorElement configured for downloading a Blob.
+ * The anchor has href set to a blob URL and target="_blank".
+ *
+ * @param blob - The Blob to download
+ * @param options - Optional configuration
+ * @param options.filename - Default filename for download (can be overridden later with anchor.download)
+ * @param options.target - Target attribute for anchor (default: '_blank')
+ * @returns Object containing the anchor element and blob URL (for cleanup)
+ *
+ * @example
+ * ```ts
+ * const blob = new Blob(['Hello'], { type: 'text/plain' })
+ * const { anchor, blobUrl } = createDownloadAnchor(blob, { filename: 'hello.txt' })
+ *
+ * // Dont forget to cleanup while done
+ * URL.revokeObjectURL(blobUrl)
+ * ```
+ */
+export declare const createDownloadAnchor: ICreateDownloadAnchor;
+/**
+ * Triggers a download of a Blob by creating a temporary anchor, clicking it, and cleaning up.
+ * This is a one-shot download function that handles all cleanup automatically.
+ *
+ * @param blob - The Blob to download
+ * @param filename - The filename for the download
+ *
+ * @example
+ * ```ts
+ * const blob = new Blob(['Hello World'], { type: 'text/plain' })
+ * downloadBlob(blob, 'hello.txt')
+ * // Download starts immediately, cleanup is automatic
+ * ```
+ */
+export declare const downloadBlob: IDownloadBlob;
+export {};

package/dist/utils/file.js

@@ -0,0 +1,200 @@
+/**
+ * Check if an image URL is valid by attempting to load it.
+ *
+ * @param url - The image URL to check.
+ */
+export var checkImage = function (url) {
+    return new Promise(function (resolve) {
+        var img = new Image();
+        img.src = url;
+        img.onload = function () { return resolve(url); };
+        img.onerror = function () { return resolve(''); };
+    });
+};
+/**
+ * Converts a Blob object into a Base64-encoded data URL string.
+ *
+ * @param blob - The Blob object to be converted.
+ * @returns - A Promise that resolves to a Base64-encoded data URL string.
+ */
+export var convertBlob = function (blob) {
+    return new Promise(function (resolve) {
+        var reader = new FileReader();
+        reader.onload = function () { return resolve(reader.result); };
+        reader.readAsDataURL(blob);
+    });
+};
+/**
+ * Gets the file extension suggestion based on MIME type
+ *
+ * @param mimeType - The MIME type string
+ * @returns Suggested file extension (without dot)
+ *
+ * @example
+ * ```ts
+ * const ext = getExtension('application/pdf')
+ * console.log(ext) // 'pdf'
+ * ```
+ */
+export function getExtension(mimeType) {
+    var cleanMimeType = mimeType.split(';')[0].trim().toLowerCase();
+    var mimeMap = {
+        'application/pdf': 'pdf',
+        'application/msword': 'doc',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+        'application/vnd.ms-excel': 'xls',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+        'application/vnd.ms-powerpoint': 'ppt',
+        'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'pptx',
+        'application/vnd.oasis.opendocument.text': 'odt',
+        'application/vnd.oasis.opendocument.spreadsheet': 'ods',
+        'application/vnd.oasis.opendocument.presentation': 'odp',
+        'application/rtf': 'rtf',
+        'application/json': 'json',
+        'application/xml': 'xml',
+        'application/yaml': 'yaml',
+        'text/xml': 'xml',
+        'text/csv': 'csv',
+        'text/plain': 'txt',
+        'text/markdown': 'md',
+        'text/html': 'html',
+        'text/css': 'css',
+        'text/javascript': 'js',
+        'application/javascript': 'js',
+        'application/typescript': 'ts',
+        'application/xhtml+xml': 'xhtml',
+        'application/zip': 'zip',
+        'application/x-rar-compressed': 'rar',
+        'application/x-7z-compressed': '7z',
+        'application/gzip': 'gz',
+        'application/x-tar': 'tar',
+        'application/x-bzip2': 'bz2',
+        'image/png': 'png',
+        'image/jpeg': 'jpg',
+        'image/gif': 'gif',
+        'image/svg+xml': 'svg',
+        'image/webp': 'webp',
+        'image/bmp': 'bmp',
+        'image/tiff': 'tiff',
+        'image/x-icon': 'ico',
+        'image/vnd.microsoft.icon': 'ico',
+        'image/heic': 'heic',
+        'image/heif': 'heif',
+        'image/avif': 'avif',
+        'video/mp4': 'mp4',
+        'video/webm': 'webm',
+        'video/x-msvideo': 'avi',
+        'video/quicktime': 'mov',
+        'video/x-matroska': 'mkv',
+        'video/mpeg': 'mpeg',
+        'video/x-flv': 'flv',
+        'video/3gpp': '3gp',
+        'audio/mpeg': 'mp3',
+        'audio/wav': 'wav',
+        'audio/ogg': 'ogg',
+        'audio/webm': 'weba',
+        'audio/aac': 'aac',
+        'audio/flac': 'flac',
+        'audio/x-m4a': 'm4a',
+        'audio/midi': 'midi',
+        'font/woff': 'woff',
+        'font/woff2': 'woff2',
+        'font/ttf': 'ttf',
+        'font/otf': 'otf',
+        'application/font-woff': 'woff',
+        'application/font-woff2': 'woff2',
+        'application/x-font-ttf': 'ttf',
+        'application/x-font-otf': 'otf',
+        'application/octet-stream': 'bin',
+        'application/x-shockwave-flash': 'swf',
+        'application/vnd.apple.installer+xml': 'mpkg',
+        'application/x-apple-diskimage': 'dmg',
+    };
+    if (mimeMap[cleanMimeType]) {
+        return mimeMap[cleanMimeType];
+    }
+    var parts = cleanMimeType.split('/');
+    if (parts.length === 2) {
+        var subtype = parts[1];
+        subtype = subtype.replace(/^(x-|vnd\.)/, '');
+        subtype = subtype.split('+')[0];
+        var dashParts = subtype.split('-');
+        subtype = dashParts[dashParts.length - 1];
+        if (subtype && /^[a-z0-9]{2,4}$/.test(subtype)) {
+            return subtype;
+        }
+    }
+    return 'bin';
+}
+/**
+ * Generates a suggested filename from a Blob based on its MIME type
+ *
+ * @param blob - The Blob to generate filename for
+ * @param prefix - Optional prefix for the filename (default: 'download')
+ * @returns Suggested filename with extension
+ *
+ * @example
+ * ```ts
+ * const blob = new Blob(['data'], { type: 'application/pdf' })
+ * const filename = filenameWithExtension(blob)
+ * console.log(filename) // 'download.pdf'
+ * ```
+ */
+export function filenameWithExtension(blob, prefix) {
+    if (prefix === void 0) { prefix = 'download'; }
+    var ext = getExtension(blob.type);
+    return "".concat(prefix, ".").concat(ext);
+}
+/**
+ * Creates an HTMLAnchorElement configured for downloading a Blob.
+ * The anchor has href set to a blob URL and target="_blank".
+ *
+ * @param blob - The Blob to download
+ * @param options - Optional configuration
+ * @param options.filename - Default filename for download (can be overridden later with anchor.download)
+ * @param options.target - Target attribute for anchor (default: '_blank')
+ * @returns Object containing the anchor element and blob URL (for cleanup)
+ *
+ * @example
+ * ```ts
+ * const blob = new Blob(['Hello'], { type: 'text/plain' })
+ * const { anchor, blobUrl } = createDownloadAnchor(blob, { filename: 'hello.txt' })
+ *
+ * // Dont forget to cleanup while done
+ * URL.revokeObjectURL(blobUrl)
+ * ```
+ */
+export var createDownloadAnchor = function (blob, options) {
+    var _a;
+    var blobUrl = URL.createObjectURL(blob);
+    var anchor = document.createElement('a');
+    anchor.href = blobUrl;
+    anchor.target = (_a = options === null || options === void 0 ? void 0 : options.target) !== null && _a !== void 0 ? _a : '_blank';
+    if (options === null || options === void 0 ? void 0 : options.filename) {
+        anchor.download = options.filename;
+    }
+    return { anchor: anchor, blobUrl: blobUrl };
+};
+/**
+ * Triggers a download of a Blob by creating a temporary anchor, clicking it, and cleaning up.
+ * This is a one-shot download function that handles all cleanup automatically.
+ *
+ * @param blob - The Blob to download
+ * @param filename - The filename for the download
+ *
+ * @example
+ * ```ts
+ * const blob = new Blob(['Hello World'], { type: 'text/plain' })
+ * downloadBlob(blob, 'hello.txt')
+ * // Download starts immediately, cleanup is automatic
+ * ```
+ */
+export var downloadBlob = function (blob, filename) {
+    var _a = createDownloadAnchor(blob, { filename: filename }), anchor = _a.anchor, blobUrl = _a.blobUrl;
+    document.body.appendChild(anchor);
+    anchor.click();
+    document.body.removeChild(anchor);
+    setTimeout(function () {
+        URL.revokeObjectURL(blobUrl);
+    }, 100);
+};

package/dist/utils/general.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Get a DOM element by its ID.
+ *
+ * @param id - The ID of the element to get.
+ */
+export declare const getById: <T = HTMLElement>(id: string) => T;
+/**
+ * Get a DOM element by any valid CSS selector.
+ *
+ * @param str - A string containing a CSS selector to match an element in the document.
+ */
+export declare const getByAny: <T = HTMLElement>(str: string) => T;
+/**
+ * Trigger a click event on an element by its ID.
+ *
+ * @param id - The ID of the element to click.
+ */
+export declare const clickById: (id: string) => void;
+/**
+ * Focus an element by its ID.
+ *
+ * @param id - The ID of the element to focus.
+ */
+export declare const focusById: (id: string) => void;
+/**
+ * Smoothly scrolls the window to an element's position when click on active Link.
+ *
+ * @param hash - Hash of the link.
+ * @param currentHash - Current hash in URL.
+ * @param func - Optional function to triggered before main logic.
+ */
+export declare const handleHashLink: (hash: string, currentHash: string, func?: () => void) => void;
+/**
+ * Get acronym (max 2 characters) from a full name string.
+ *
+ * @param name - Full name string.
+ */
+export declare const acronym: (name: string) => string;
+/**
+ * Check primitive data type status of a value
+ *
+ * @param value
+ * @returns - data type status
+ */
+export declare const isNotPrimitive: (value: unknown) => value is object;

package/dist/utils/general.js

@@ -0,0 +1,75 @@
+/**
+ * Get a DOM element by its ID.
+ *
+ * @param id - The ID of the element to get.
+ */
+export var getById = function (id) { return document.getElementById(id); };
+/**
+ * Get a DOM element by any valid CSS selector.
+ *
+ * @param str - A string containing a CSS selector to match an element in the document.
+ */
+export var getByAny = function (str) { return document.querySelector(str); };
+/**
+ * Trigger a click event on an element by its ID.
+ *
+ * @param id - The ID of the element to click.
+ */
+export var clickById = function (id) {
+    var el = getById(id);
+    if (el) {
+        el.click();
+    }
+};
+/**
+ * Focus an element by its ID.
+ *
+ * @param id - The ID of the element to focus.
+ */
+export var focusById = function (id) {
+    var el = getById(id);
+    if (el) {
+        el.focus();
+    }
+};
+/**
+ * Smoothly scrolls the window to an element's position when click on active Link.
+ *
+ * @param hash - Hash of the link.
+ * @param currentHash - Current hash in URL.
+ * @param func - Optional function to triggered before main logic.
+ */
+export var handleHashLink = function (hash, currentHash, func) {
+    if (func)
+        func();
+    if (hash === currentHash) {
+        if (!hash) {
+            window.scrollTo({ top: 0, behavior: 'smooth' });
+            return;
+        }
+        var target = getByAny(hash);
+        target.scrollIntoView({ behavior: 'smooth' });
+    }
+};
+/**
+ * Get acronym (max 2 characters) from a full name string.
+ *
+ * @param name - Full name string.
+ */
+export var acronym = function (name) {
+    var parts = name.trim().split(/\s+/);
+    if (parts.length === 0)
+        return '.';
+    if (parts.length === 1)
+        return parts[0][0].toUpperCase();
+    return (parts[0][0] + parts[1][0]).toUpperCase();
+};
+/**
+ * Check primitive data type status of a value
+ *
+ * @param value
+ * @returns - data type status
+ */
+export var isNotPrimitive = function (value) {
+    return typeof value === 'object' && value !== null;
+};

package/dist/utils/local.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Clear localStorage.
+ */
+export declare const clearLocals: () => void;
+/**
+ * Removes an item from localStorage by key.
+ *
+ * @param key - The key of the item to remove.
+ */
+export declare const removeLocal: (key: string) => void;
+/**
+ * Sets an item in localStorage after serializing it to JSON.
+ *
+ * @param key - The key under which to store the value.
+ * @param value - The value to store (will be JSON-stringified).
+ */
+export declare const setLocal: <T>(key: string, value: T) => void;
+/**
+ * Sets multiple items in localStorage after serializing it to JSON.
+ *
+ * @param items - Array of local storage items to set.
+ */
+export declare const setLocals: <T extends Record<string, unknown>>(items: { [K in keyof T]: {
+    key: K & string;
+    value: T[K];
+}; }[keyof T][]) => void;
+/**
+ * Retrieves and parses a JSON item from localStorage by key.
+ *
+ * @param key - The key of the item to retrieve.
+ * @returns The parsed value from localStorage, or null if not found.
+ */
+export declare const getLocal: <T>(key: string) => T | null;
+/**
+ * Retrieves and parses multiple JSON items from localStorage by key.
+ *
+ * @param keys - The keys of the items to retrieve.
+ * @returns The parsed values from localStorage.
+ */
+export declare const getLocals: <T extends Record<string, unknown>, K extends keyof T = keyof T>(keys: readonly K[]) => { [P in K]: T[P] | null; };

package/dist/utils/local.js

@@ -0,0 +1,54 @@
+/**
+ * Clear localStorage.
+ */
+export var clearLocals = function () { return localStorage.clear(); };
+/**
+ * Removes an item from localStorage by key.
+ *
+ * @param key - The key of the item to remove.
+ */
+export var removeLocal = function (key) { return localStorage.removeItem(key); };
+/**
+ * Sets an item in localStorage after serializing it to JSON.
+ *
+ * @param key - The key under which to store the value.
+ * @param value - The value to store (will be JSON-stringified).
+ */
+export var setLocal = function (key, value) { return localStorage.setItem(key, JSON.stringify(value)); };
+/**
+ * Sets multiple items in localStorage after serializing it to JSON.
+ *
+ * @param items - Array of local storage items to set.
+ */
+export var setLocals = function (items) {
+    items.forEach(function (item) { return setLocal(item.key, item.value); });
+};
+/**
+ * Retrieves and parses a JSON item from localStorage by key.
+ *
+ * @param key - The key of the item to retrieve.
+ * @returns The parsed value from localStorage, or null if not found.
+ */
+export var getLocal = function (key) {
+    var item = localStorage.getItem(key);
+    try {
+        if (item)
+            return JSON.parse(item);
+        return null;
+    }
+    catch (_a) {
+        return item;
+    }
+};
+/**
+ * Retrieves and parses multiple JSON items from localStorage by key.
+ *
+ * @param keys - The keys of the items to retrieve.
+ * @returns The parsed values from localStorage.
+ */
+export var getLocals = function (keys) {
+    return keys.reduce(function (acc, key) {
+        acc[key] = getLocal(key);
+        return acc;
+    }, {});
+};

package/dist/utils/useApi.d.ts

@@ -0,0 +1,94 @@
+import { type IApiInterceptor, type TApiConfig, type TApiInstanceOptions, type TApiResponse, type THttpConfig, type TProgress } from './api';
+type TFetchState<T> = {
+    data: T | null;
+    error: unknown;
+    isLoading: boolean;
+    cacheKey: string | null;
+};
+type TFetchResult<T> = TFetchState<T> & {
+    refetch: () => Promise<TFetchState<T>>;
+};
+type TMutationOptions = Pick<TApiConfig, 'cache' | 'headers' | 'method' | 'signal'> & {
+    progress?: 'upload' | 'download';
+    queryMutation?: boolean;
+};
+type TMutationResult<TData, TRequest> = {
+    mutate: (request?: TRequest) => Promise<TApiResponse<TData>>;
+    isLoading: boolean;
+    cacheKey: string | null;
+    progress: TProgress | null;
+};
+type TInfiniteFetchOptions<T> = {
+    initialOffset: number;
+    offsetKey?: string;
+    setOffset: (lastItems: T, allItems: T[], lastOffset: number) => number | null;
+};
+/**
+ * Creates a new API instance with built-in React hooks (`fetch`, `mutation`, `infinite`)
+ * for performing typed data fetching and mutations with progress tracking.
+ *
+ * @param options - Optional configuration for the API instance (e.g. baseURL, default headers).
+ * @returns An object containing data hooks (`fetch`, `mutation`, `infinite`), cache manipulation methods, and interceptor registration.
+ *
+ * @example
+ * ```tsx
+ * const api = createApi({ baseURL: '/api' })
+ *
+ * const { data, isLoading, refetch } = api.fetch<User[]>('/users')
+ *
+ * const { mutate, isLoading, progress } = api.mutation<User, FormData>('/users', { method: 'POST' })
+ *
+ * const { data, isLoading, refetch } = api.infinite<User[]>('/users', { initialOffset: 0 })
+ * ```
+ */
+export default function createApi(options?: TApiInstanceOptions): {
+    fetch: <T>(url: string, config?: Omit<THttpConfig, "onUpload" | "onDownload">, enabled?: boolean) => TFetchResult<T>;
+    mutation: <TData, TRequest = void>(url: string, config?: TMutationOptions) => TMutationResult<TData, TRequest>;
+    infinite: <T>(url: string, options: TInfiniteFetchOptions<T>, config?: THttpConfig) => {
+        data: T[];
+        error: unknown;
+        isLoading: boolean;
+        hasNextPage: boolean;
+        isFetchingNextPage: boolean;
+        fetchNextPage: () => Promise<void>;
+        refetch: () => Promise<void>;
+    };
+    /**
+     * Retrieves a cached response by its key.
+     * @param key - Unique cache key.
+     * @returns Cached data or `undefined` if not found.
+     */
+    getCache: <T>(key: string) => T | undefined;
+    /**
+     * Stores data in cache.
+     * @param key - Cache key.
+     * @param data - Data to store.
+     * @param ttl - Optional time-to-live in milliseconds.
+     */
+    setCache: <T>(key: string, data: T, ttl?: number) => void;
+    /**
+     * Removes a single cached entry.
+     * @param key - Cache key to remove.
+     */
+    removeCache: (key: string) => void;
+    /**
+     * Clears all cache entries.
+     */
+    clearCache: () => void;
+    /**
+     * Registers custom request/response interceptors.
+     *
+     * @param interceptors - Object containing optional `request`, `response`, and `error` interceptors.
+     *
+     * @example
+     * ```ts
+     * api.setInterceptors({
+     *   request: config => config,
+     *   response: res => res,
+     *   error: err => Promise.reject(err),
+     * })
+     * ```
+     */
+    setInterceptors: (interceptors: IApiInterceptor) => void;
+};
+export {};