@fajarmaulana/komerce-lp-helper 0.1.0

package/dist/hooks/slider.js

@@ -0,0 +1,167 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useMemo, useRef, useState } from 'react';
+import { MOBILE_BOUND } from '@/constants';
+/**
+ * Get slider position from an event, supports mobile touch events.
+ *
+ * @param e - The event object of MouseEvent or TouchEvent.
+ * @param mobile - Whether the event is from a mobile touch (default: false).
+ * @param axis - The axis to get position from, either 'X' or 'Y' (default: 'X').
+ * @returns The page X or Y coordinate from the event.
+ */
+export function slider(_a) {
+    var e = _a.e, mobile = _a.mobile, axis = _a.axis;
+    return mobile ? e.changedTouches[0]["page".concat(axis)] : e["page".concat(axis)];
+}
+/**
+ * useSlider is a custom hook to manage the logic for the slider component.
+ *
+ * @param data - An array of data to display in the slider.
+ * @param mobileOnly - Boolean indicating whether the slider is showed on mobile only or not.
+ * @param infiniteSlide - Boolean indicating whether the slider can be slided infinitely or not.
+ * @param isLoading - Boolean indicating whether the data is still loading.
+ * @param mobileBound - Number as bound for mobile only mode
+ * @param onNext - Emited method to override the next function.
+ * @param onBack - Emited method to override the back function.
+ * @returns An object containing state values and handlers for slider control and interaction.
+ */
+export function useSlider(_a) {
+    var data = _a.data, mobileOnly = _a.mobileOnly, infiniteSlide = _a.infiniteSlide, isLoading = _a.isLoading, mobileBound = _a.mobileBound, onBack = _a.onBack, onNext = _a.onNext;
+    var _b = __read(useState(0), 2), currentSlide = _b[0], setCurrentSlide = _b[1];
+    var _c = __read(useState(0), 2), movement = _c[0], setMovement = _c[1];
+    var _d = __read(useState(false), 2), grab = _d[0], setGrab = _d[1];
+    var startRef = useRef(0);
+    var endRef = useRef(0);
+    var throttleRef = useRef(false);
+    /**
+     * Determines whether the left navigation arrow should be disabled.
+     */
+    var disableLeftArrow = useMemo(function () {
+        return currentSlide === 0 || data.length === 0 || isLoading;
+    }, [currentSlide, data, isLoading]);
+    /**
+     * Determines whether the right navigation arrow should be disabled.
+     */
+    var disableRightArrow = useMemo(function () {
+        return currentSlide === data.length - 1 || data.length === 0 || isLoading;
+    }, [currentSlide, data, isLoading]);
+    /**
+     * Begins drag or swipe interaction for the slider.
+     *
+     * @param e - Mouse or touch event.
+     * @param param - Optional parameter to indicate a mobile event. Defaults to `true`.
+     */
+    var startSlide = function (param) {
+        if (mobileOnly && window.innerWidth >= (mobileBound || MOBILE_BOUND))
+            return;
+        startRef.current = slider(param);
+        setGrab(true);
+    };
+    /**
+     * Handles the ongoing drag/swipe movement of the slider.
+     *
+     * @param e - Mouse or touch event.
+     * @param param - Optional parameter to indicate a mobile event.
+     */
+    var moveSlide = function (param) {
+        if (mobileOnly && window.innerWidth >= (mobileBound || MOBILE_BOUND))
+            return;
+        var diff = slider(param) - startRef.current;
+        var move = param.mobile && Math.abs(diff) <= 24 ? 0 : diff;
+        if (!onNext || !onBack) {
+            var len = data.length - 1;
+            if (currentSlide === 0 && move > 0)
+                setCurrentSlide(0);
+            if (currentSlide === len && move < 0)
+                setCurrentSlide(len);
+        }
+        setMovement(move);
+    };
+    /**
+     * Throttle call of next and back function.
+     */
+    var throttle = function (callback, delay) {
+        if (delay === void 0) { delay = 100; }
+        if (throttleRef.current)
+            return;
+        throttleRef.current = true;
+        callback();
+        setTimeout(function () {
+            throttleRef.current = false;
+        }, delay);
+    };
+    /**
+     * Navigates to the next slide if possible.
+     */
+    var next = function () {
+        if (disableRightArrow && !infiniteSlide)
+            return;
+        throttle(function () {
+            if (disableRightArrow) {
+                setCurrentSlide(0);
+                return;
+            }
+            setCurrentSlide(function (prev) { return prev + 1; });
+        });
+    };
+    /**
+     * Navigates to the previous slide if possible.
+     */
+    var back = function () {
+        if (disableLeftArrow && !infiniteSlide)
+            return;
+        throttle(function () {
+            if (disableLeftArrow) {
+                setCurrentSlide(data.length - 1);
+                return;
+            }
+            setCurrentSlide(function (prev) { return prev - 1; });
+        });
+    };
+    /**
+     * Ends the drag or swipe interaction and determines if a slide change should occur.
+     *
+     * @param e - Mouse or touch event.
+     * @param param - Optional parameter to indicate a mobile event.
+     */
+    var endSlide = function (param) {
+        if (mobileOnly && window.innerWidth >= (mobileBound || MOBILE_BOUND))
+            return;
+        setGrab(false);
+        endRef.current = slider(param);
+        if (startRef.current > endRef.current && startRef.current - endRef.current > 64)
+            onNext ? onNext() : next();
+        if (startRef.current < endRef.current && endRef.current - startRef.current > 64)
+            onBack ? onBack() : back();
+        setMovement(0);
+    };
+    return {
+        currentSlide: currentSlide,
+        movement: movement,
+        grab: grab,
+        disableLeftArrow: disableLeftArrow,
+        disableRightArrow: disableRightArrow,
+        setCurrentSlide: setCurrentSlide,
+        startSlide: startSlide,
+        moveSlide: moveSlide,
+        endSlide: endSlide,
+        next: next,
+        back: back,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./constants";
+export * from "./hooks/debounce";
+export * from "./hooks/router";
+export * from "./hooks/slider";
+export * from "./types";
+export { default as http, ApiInstance, ApiMeta } from "./utils/api";
+export * from "./utils/cookie";
+export * from "./utils/file";
+export * from "./utils/general";
+export * from "./utils/local";
+export { default as createApi } from "./utils/useApi";

package/dist/index.js

@@ -0,0 +1,11 @@
+export * from "./constants";
+export * from "./hooks/debounce";
+export * from "./hooks/router";
+export * from "./hooks/slider";
+export * from "./types";
+export { default as http, ApiInstance, ApiMeta } from "./utils/api";
+export * from "./utils/cookie";
+export * from "./utils/file";
+export * from "./utils/general";
+export * from "./utils/local";
+export { default as createApi } from "./utils/useApi";

package/dist/types/enum.d.ts

@@ -0,0 +1,12 @@
+export declare enum EStatus {
+    Error = "error",
+    Success = "success",
+    Info = "info",
+    Warning = "warning"
+}
+export declare enum ERegisterMode {
+    Register = "Register",
+    Registered = "Registered",
+    RegisteredAsOther = "RegisteredAsOther",
+    Login = "Login"
+}

package/dist/types/enum.js

@@ -0,0 +1,14 @@
+export var EStatus;
+(function (EStatus) {
+    EStatus["Error"] = "error";
+    EStatus["Success"] = "success";
+    EStatus["Info"] = "info";
+    EStatus["Warning"] = "warning";
+})(EStatus || (EStatus = {}));
+export var ERegisterMode;
+(function (ERegisterMode) {
+    ERegisterMode["Register"] = "Register";
+    ERegisterMode["Registered"] = "Registered";
+    ERegisterMode["RegisteredAsOther"] = "RegisteredAsOther";
+    ERegisterMode["Login"] = "Login";
+})(ERegisterMode || (ERegisterMode = {}));

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export type * from "./meta.d.ts";

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/api.d.ts

@@ -0,0 +1,274 @@
+export type TPrimitive = string | number | boolean;
+export type TProgress = {
+    loaded: number;
+    total: number;
+    percentage: number;
+};
+export type TProgressCallback = (progress: TProgress) => void;
+export type THttpConfig = {
+    /** Optional request headers */
+    headers?: Record<string, string>;
+    /** Query parameters for the request */
+    params?: Record<string, TPrimitive | TPrimitive[]>;
+    /** Optional cache configuration */
+    cache?: {
+        /** Enable or disable caching for this request */
+        enabled?: boolean;
+        /** Cache revalidation time in milliseconds */
+        revalidate?: number;
+    };
+    /** Abort signal to cancel the request */
+    signal?: AbortSignal;
+    /** Upload progress callback */
+    onUpload?: TProgressCallback;
+    /** Download progress callback */
+    onDownload?: TProgressCallback;
+};
+export type TCacheEntry<T> = {
+    /** Cached data */
+    data: T;
+    /** Timestamp when the data was cached */
+    timestamp: number;
+    /** Optional time-to-live (TTL) in milliseconds */
+    ttl?: number;
+};
+export type TApiConfig = {
+    /** Base URL of the API */
+    baseURL?: string;
+    /** Endpoint URL (relative or absolute) */
+    url: string;
+    /** HTTP method for the request */
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    /** Request body content */
+    body?: globalThis.BodyInit;
+    /** Request mode (e.g., 'cors', 'same-origin') */
+    mode?: globalThis.RequestMode;
+    /** Number of retry attempts on failure */
+    retry?: number;
+} & THttpConfig;
+export type TApiInstanceOptions = {
+    /** Base URL applied to all requests from this instance */
+    baseURL?: string;
+    /** Default headers applied to all requests */
+    headers?: Record<string, string>;
+    /** Source identifier used for cache scoping */
+    source?: string;
+    /** Maximum number of cache entries to store */
+    maxCacheSize?: number;
+};
+export type TApiResponse<T> = {
+    /** Parsed JSON data from the response */
+    data: T;
+    /** Unique key identifying this request (for caching) */
+    cacheKey?: string;
+    /** Indicates whether the data was served from cache */
+    fromCache: boolean;
+};
+export interface IApiInterceptor {
+    /**
+     * Intercept and modify the request configuration before sending.
+     * @param config{@link TApiConfig}: The outgoing request configuration
+     */
+    request?: (config: TApiConfig) => TApiConfig | Promise<TApiConfig>;
+    /**
+     * Intercept and modify the response before returning.
+     * @param response The received Response object
+     */
+    response?: (response: Response) => Response | Promise<Response>;
+    /**
+     * Handle errors thrown during the request lifecycle.
+     * @param error The thrown error object
+     */
+    error?: (error: unknown) => Promise<unknown>;
+}
+interface IApiInstance {
+    /**
+     * Registers custom interceptors for requests and responses.
+     *
+     * @param interceptors{@link IApiInterceptor}: Object containing optional `request`, `response`, and `error` interceptors.
+     *
+     * @example
+     * ```ts
+     * api.setInterceptors({
+     *   request: config => ({ ...config, headers: { ...config.headers, Authorization: 'Bearer token' } }),
+     *   response: response => response,
+     *   error: error => Promise.reject(error),
+     * })
+     * ```
+     */
+    setInterceptors(interceptors: IApiInterceptor): void;
+    /**
+     * Sends a general API request with full configuration control.
+     *
+     * @template T - The expected response data type.
+     * @param config{@link TApiConfig}: Full request configuration including URL, method, params, headers, etc.
+     * @returns A promise that resolves to the API response.
+     *
+     * @example
+     * ```ts
+     * const res = await api.request<{ users: User[] }>({
+     *   url: '/users',
+     *   method: 'GET',
+     *   cache: { enabled: true, revalidate: 5000 },
+     * })
+     * ```
+     */
+    request<T>(config: TApiConfig): Promise<TApiResponse<T>>;
+    /**
+     * Performs a GET request.
+     *
+     * @template T - The expected response data type.
+     * @param url - The request URL.
+     * @param config{@link TApiConfig}: Optional request configuration (headers, params, cache, etc).
+     * @returns A promise resolving to the API response.
+     *
+     * @example
+     * ```ts
+     * const res = await api.get<User[]>('/users')
+     * ```
+     */
+    get<T>(url: string, config?: THttpConfig): Promise<TApiResponse<T>>;
+    /**
+     * Performs a POST request.
+     *
+     * @template T - The expected response data type.
+     * @param url - The request URL.
+     * @param body - Optional request body.
+     * @param config{@link TApiConfig}: Optional request configuration.
+     * @returns A promise resolving to the API response.
+     *
+     * @example
+     * ```ts
+     * const res = await api.post<User>('/users', JSON.stringify({ name: 'John' }))
+     * ```
+     */
+    post<T, U = unknown>(url: string, body?: U, config?: THttpConfig): Promise<TApiResponse<T>>;
+    /**
+     * Performs a PUT request.
+     *
+     * @template T - The expected response data type.
+     * @param url - The request URL.
+     * @param body - Optional request body.
+     * @param config{@link TApiConfig}: Optional request configuration.
+     * @returns A promise resolving to the API response.
+     */
+    put<T, U = unknown>(url: string, body?: U, config?: THttpConfig): Promise<TApiResponse<T>>;
+    /**
+     * Performs a PATCH request.
+     *
+     * @template T - The expected response data type.
+     * @param url - The request URL.
+     * @param body - Optional request body.
+     * @param config{@link TApiConfig}: Optional request configuration.
+     * @returns A promise resolving to the API response.
+     */
+    patch<T, U = unknown>(url: string, body?: U, config?: THttpConfig): Promise<TApiResponse<T>>;
+    /**
+     * Performs a DELETE request.
+     *
+     * @template T - The expected response data type.
+     * @param url - The request URL.
+     * @param body - Optional request body.
+     * @param config{@link TApiConfig}: Optional request configuration.
+     * @returns A promise resolving to the API response.
+     */
+    delete<T, U = unknown>(url: string, body?: U, config?: THttpConfig): Promise<TApiResponse<T>>;
+    /**
+     * Retrieves a cached response by key.
+     *
+     * @template T - Type of cached data.
+     * @param key - Cache key used during the request.
+     * @returns Cached data if available, otherwise `undefined`.
+     *
+     * @example
+     * ```ts
+     * const cached = api.getCache<User[]>('users:list')
+     * ```
+     */
+    getCache<T>(key: string): T | undefined;
+    /**
+     * Manually stores data in cache.
+     *
+     * @template T - Type of data to cache.
+     * @param key - Cache key.
+     * @param data - Data to store.
+     * @param ttl - Optional time-to-live (milliseconds).
+     *
+     * @example
+     * ```ts
+     * api.setCache('user:1', { id: 1, name: 'John' }, 5000)
+     * ```
+     */
+    setCache<T>(key: string, data: T, ttl?: number): void;
+    /**
+     * Removes a specific cache entry by key.
+     *
+     * @param key - Cache key to remove.
+     *
+     * @example
+     * ```ts
+     * api.removeCache('user:1')
+     * ```
+     */
+    removeCache(key: string): void;
+    /**
+     * Clears all cache entries from the instance.
+     *
+     * @example
+     * ```ts
+     * api.clearCache()
+     * ```
+     */
+    clearCache(): void;
+}
+export declare const buildURL: (url: string, params?: THttpConfig["params"]) => string;
+export declare class ApiMeta extends Error {
+    code: number;
+    status: string;
+    constructor(code: number, message: string, status: string);
+}
+export declare class ApiInstance implements IApiInstance {
+    private baseURL;
+    private defaultHeaders;
+    private interceptors;
+    private source;
+    private cache;
+    private maxCacheSize;
+    private cacheAccessOrder;
+    constructor(options?: TApiInstanceOptions);
+    setInterceptors(interceptors: IApiInterceptor): void;
+    private hash;
+    private buildcacheKey;
+    private fetchWithXHR;
+    private fetchWithRetry;
+    private handleInterceptors;
+    private handleResponse;
+    private handleError;
+    private getCacheEntry;
+    private setCacheEntry;
+    private removeCacheEntry;
+    request<T>(config: TApiConfig): Promise<TApiResponse<T>>;
+    get<T>(url: string, config?: THttpConfig): Promise<TApiResponse<T>>;
+    post<T, U = unknown>(url: string, body?: U, config?: THttpConfig): Promise<TApiResponse<T>>;
+    put<T, U = unknown>(url: string, body?: U, config?: THttpConfig): Promise<TApiResponse<T>>;
+    patch<T, U = unknown>(url: string, body?: U, config?: THttpConfig): Promise<TApiResponse<T>>;
+    delete<T, U = unknown>(url: string, body?: U, config?: THttpConfig): Promise<TApiResponse<T>>;
+    getCache<T>(key: string): T | undefined;
+    setCache<T>(key: string, data: T, ttl?: number): void;
+    removeCache(key: string): void;
+    clearCache(): void;
+}
+declare const http: {
+    get: <T>(url: string, config?: THttpConfig) => Promise<TApiResponse<T>>;
+    post: <T, U = unknown>(url: string, body?: U, config?: THttpConfig) => Promise<TApiResponse<T>>;
+    put: <T, U = unknown>(url: string, body?: U, config?: THttpConfig) => Promise<TApiResponse<T>>;
+    patch: <T, U = unknown>(url: string, body?: U, config?: THttpConfig) => Promise<TApiResponse<T>>;
+    delete: <T, U = unknown>(url: string, body?: U, config?: THttpConfig) => Promise<TApiResponse<T>>;
+    getCache: <T>(key: string) => T | undefined;
+    setCache: <T>(key: string, data: T, ttl?: number) => void;
+    removeCache: (key: string) => void;
+    clearCache: () => void;
+    request: (config: TApiConfig) => Promise<TApiResponse<unknown>>;
+    create: (options?: TApiInstanceOptions) => IApiInstance;
+};
+export default http;