@qlibs/utils 1.0.2

package/README.md

@@ -0,0 +1,98 @@
+## usePromiseAllData
+```
+const {
+    isLoadingPromiseAllData: isLoading,
+    promiseAllData,
+    fetchPromiseAllData,
+  } = usePromiseAllData<IPromiseAllData>({
+    httpRequest: httpRequest as any,
+    endpoints: [
+      {
+        endpoint: '/users/' + params.userId,
+        returnKey: 'user',
+      },
+      {
+        endpoint: selectedProgram?.programId
+          ? `evaluation-calculator/${selectedProgram?.programId}/${params.userId}`
+          : `evaluation-calculator/${params.userId}`,
+        returnKey: 'competencies',
+      },
+    ],
+  });
+
+  useEffect(() => {
+    fetchPromiseAllData();
+  }, []);
+```
+
+## useAdditionalDataForList
+```
+const { isLoadingAdditionalData, additionalData } =
+    useAdditionalDataForList<IAdditionalData>({
+      httpRequest: httpRequest as any,
+      id: 'attendanceId',
+      data,
+      injects: [
+        {
+          injectedId: 'userId',
+          endpoint: '/users?filterStatus=active&roles=talent&userIds=',
+          endpointId: 'userId',
+          returnKey: 'user',
+        },
+        props.type === 'EVENT' ? {
+          injectedId: 'eventId',
+          endpoint: '/event?eventIds=',
+          endpointId: 'eventId',
+          returnKey: 'event',
+        } : {injectedId: '', endpoint: '', returnKey: '', endpointId: ''},
+      ].filter(item => item?.injectedId),
+    });
+```
+
+## TRACK ME
+### How to use TrackMe
+```
+const {insertData} = useTrackData();
+const location = useLocation()
+
+<TrackMe 
+  appName='QLIBS'
+  userId='QLIBS_userId'
+  userData={{name: 'QLIBS_user_name'}}
+  processUpload={(
+    activities: IActivity[],
+    onSuccess: (ids: number[]) => void
+  ) => {
+    console.info('before onSuccess activities', activities);
+    onSuccess(activities.map(item => (item as any).activityId));
+  }}
+  location={location}
+  autoUploadConfig={{
+    intervalInMs: 5000,
+  }}
+  isDemo={true}
+/>
+```
+
+```
+useTrackerIndexedDB({
+  appName: "PROJECT_NAME",
+  userId: user.userId,
+  userData: user,
+  processUpload: (activities: IActivity[], onSuccess: (ids: number[]) => void) => {
+    httpRequest
+      .post(process.env.REACT_APP_API_URL_TRACKME || '', { bulk: activities })
+      .then((res: any) => {
+        onSuccess((res.data.payload || []).map((item: any) => item.activityId));
+      })
+      .catch((err) => {
+        message.error(getErrorMessage(err));
+      });
+  },
+});
+```
+
+### How to don't track me
+```
+<button data-trackme="false">WILL NOT TRACKED</button>
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils/index";
+export * from "./types/index";

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils/index"), exports);
+__exportStar(require("./types/index"), exports);

package/dist/types/config.type.d.ts

@@ -0,0 +1,33 @@
+export type ConfigState = {
+    sidebarCollapsed: boolean;
+    counterBatch: number;
+};
+export type ConfigValue = {
+    configId: string;
+    key: string;
+    value: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export interface BaseResponseProps<T> {
+    code: string;
+    message: string;
+    payload: T;
+}
+export interface BaseResponsePaginationProps<T> {
+    code: string;
+    message: string;
+    payload: {
+        count: number;
+        prev: string;
+        next: string;
+        results: Array<T>;
+    };
+}
+export interface DefaultQuery {
+    limit?: number;
+    offset?: number;
+}
+export declare const initialConfig: ConfigState;
+export type ResponseConfig = BaseResponseProps<ConfigValue>;
+export type ResponseConfigPagination = BaseResponsePaginationProps<ConfigValue>;

package/dist/types/config.type.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialConfig = void 0;
+exports.initialConfig = {
+    sidebarCollapsed: false,
+    counterBatch: 0,
+};

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './config.type';

package/dist/types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config.type"), exports);

package/dist/utils/auth.d.ts

@@ -0,0 +1,3 @@
+export declare function saveToken(token: string): void;
+export declare function getToken(): string;
+export declare function removeToken(): void;

package/dist/utils/auth.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveToken = saveToken;
+exports.getToken = getToken;
+exports.removeToken = removeToken;
+const APP_AUTH_TOKEN = 'APP_AUTH_TOKEN';
+function saveToken(token) {
+    return localStorage.setItem(APP_AUTH_TOKEN, token);
+}
+function getToken() {
+    return localStorage.getItem(APP_AUTH_TOKEN);
+}
+function removeToken() {
+    return localStorage.removeItem(APP_AUTH_TOKEN);
+}

package/dist/utils/datetime.d.ts

@@ -0,0 +1,19 @@
+export declare const thisYear: number;
+export declare const formatDate: (date: any, dateFormat?: string) => string;
+export declare const formatUrlParams: (value: string) => string;
+export declare const SHORT_DAYS_IN_WEEK: string[];
+export declare const LIST_MONTH: string[];
+export declare const LIST_MONTH_IN: string[];
+export declare const LIST_MONTH_SHORT: string[];
+export declare function getDateString(date: Date | string | undefined, format?: 'long' | 'short', formatMonth?: 'long' | 'short'): string;
+export declare function getDateTimeString(date: Date | string | undefined, format?: 'long' | 'short', formatMonth?: 'long' | 'short', returning?: {
+    year?: boolean;
+    month?: boolean;
+    date?: boolean;
+    time?: boolean;
+}): string;
+export declare function getDateRangeString(startAt: Date | string | undefined, endAt: Date | string | undefined, format?: 'long' | 'short', formatMonth?: 'long' | 'short'): string;
+export declare function getDateTimeRangeString(startAt: Date | string | undefined, endAt: Date | string | undefined, format?: 'long' | 'short', formatMonth?: 'long' | 'short'): string;
+export declare const toAcceptableApiFormat: (s?: string) => string;
+export declare const getAge: (dateString?: string, base?: string) => number;
+export declare const evnDate: (date: string) => string;

package/dist/utils/datetime.js

@@ -0,0 +1,286 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evnDate = exports.getAge = exports.toAcceptableApiFormat = exports.LIST_MONTH_SHORT = exports.LIST_MONTH_IN = exports.LIST_MONTH = exports.SHORT_DAYS_IN_WEEK = exports.formatUrlParams = exports.formatDate = exports.thisYear = void 0;
+exports.getDateString = getDateString;
+exports.getDateTimeString = getDateTimeString;
+exports.getDateRangeString = getDateRangeString;
+exports.getDateTimeRangeString = getDateTimeRangeString;
+const moment_1 = __importDefault(require("moment"));
+const date = new Date();
+exports.thisYear = date.getFullYear();
+const formatDate = (date, dateFormat) => {
+    if (!dateFormat) {
+        dateFormat = 'DD MMMM YYYY';
+    }
+    if (date) {
+        const formated = (0, moment_1.default)(new Date(date)).format(dateFormat);
+        return formated;
+    }
+    return '';
+};
+exports.formatDate = formatDate;
+const formatUrlParams = (value) => {
+    const param = value.split(' ').join('-').toLowerCase();
+    return param;
+};
+exports.formatUrlParams = formatUrlParams;
+exports.SHORT_DAYS_IN_WEEK = [
+    'Sun',
+    'Mon',
+    'Tue',
+    'Wed',
+    'Thu',
+    'Fri',
+    'Sat',
+];
+exports.LIST_MONTH = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+];
+exports.LIST_MONTH_IN = [
+    'Januari',
+    'Februari',
+    'Maret',
+    'April',
+    'Mei',
+    'Juni',
+    'Juli',
+    'Agustus',
+    'September',
+    'October',
+    'November',
+    'Desember',
+];
+exports.LIST_MONTH_SHORT = [
+    'Jan',
+    'Feb',
+    'Mar',
+    'Apr',
+    'May',
+    'Jun',
+    'Jul',
+    'Aug',
+    'Sept',
+    'Oct',
+    'Nov',
+    'Dec',
+];
+const LIST_DAY = [
+    'Minggu',
+    'Senin',
+    'Selasa',
+    'Rabu',
+    'Kamis',
+    "Jum'at",
+    'Sabtu',
+];
+function getDateString(date, format = 'long', formatMonth = 'long') {
+    if (!date) {
+        return '-';
+    }
+    if (typeof date === 'string') {
+        date = new Date(date);
+    }
+    const dayText = LIST_DAY[date.getDay()];
+    const dateText = date.getDate();
+    const monthText = formatMonth === 'long'
+        ? exports.LIST_MONTH[date.getMonth()]
+        : exports.LIST_MONTH_SHORT[date.getMonth()];
+    const yearText = date.getFullYear();
+    if (format === 'short') {
+        return dateText + ' ' + monthText + ' ' + yearText;
+    }
+    else {
+        return dayText + ', ' + dateText + ' ' + monthText + ' ' + yearText;
+    }
+}
+function getDateTimeString(date, format = 'long', formatMonth = 'long', returning) {
+    if (!date) {
+        return '-';
+    }
+    if (typeof date === 'string') {
+        date = new Date(date);
+    }
+    let hours = date.getHours();
+    let hoursText = '';
+    if (hours < 10) {
+        hoursText = '0' + String(hours);
+    }
+    else {
+        hoursText = String(hours);
+    }
+    let minutes = date.getMinutes();
+    let minutesText = '';
+    if (minutes < 10) {
+        minutesText = '0' + String(minutes);
+    }
+    else {
+        minutesText = String(minutes);
+    }
+    const dayText = LIST_DAY[date.getDay()];
+    const dateText = date.getDate();
+    const monthText = formatMonth === 'long'
+        ? exports.LIST_MONTH[date.getMonth()]
+        : exports.LIST_MONTH_SHORT[date.getMonth()];
+    const yearText = date.getFullYear();
+    let dtString = [dateText, monthText, yearText, hoursText + ':' + minutesText];
+    if (returning) {
+        dtString = [];
+        if (returning.date) {
+            dtString.push(dateText);
+        }
+        if (returning.month) {
+            dtString.push(monthText);
+        }
+        if (returning.year) {
+            dtString.push(yearText);
+        }
+        if (returning.time) {
+            dtString.push(hoursText + ':' + minutesText);
+        }
+    }
+    if (format === 'long') {
+        dtString.unshift(dayText + ', ');
+    }
+    return dtString.join(' ');
+}
+function getDateRangeString(startAt, endAt, format = 'short', formatMonth = 'long') {
+    if (startAt && !endAt) {
+        return getDateString(startAt, format, formatMonth);
+    }
+    else if (!startAt && endAt) {
+        return getDateString(endAt, format, formatMonth);
+    }
+    else if (startAt &&
+        endAt &&
+        new Date(startAt).getTime() === new Date(endAt).getTime()) {
+        return getDateString(startAt, format, formatMonth);
+    }
+    else if (startAt && endAt) {
+        const dateStartAt = new Date(startAt);
+        const dateStartAtYear = dateStartAt.getFullYear();
+        const dateStartAtMonth = dateStartAt.getMonth();
+        const dateStartAtDate = dateStartAt.getDate();
+        const dateEndAt = new Date(endAt);
+        const dateEndAtYear = dateEndAt.getFullYear();
+        const dateEndAtMonth = dateEndAt.getMonth();
+        const dateEndAtDate = dateEndAt.getDate();
+        if (dateStartAtYear === dateEndAtYear) {
+            if (dateStartAtMonth === dateEndAtMonth) {
+                if (dateStartAtDate === dateEndAtDate) {
+                    return getDateString(startAt, format, formatMonth);
+                }
+                else {
+                    return (dateStartAtDate + ' - ' + getDateString(endAt, format, formatMonth));
+                }
+            }
+            else {
+                return (dateStartAtDate +
+                    ' ' +
+                    (formatMonth === 'long'
+                        ? exports.LIST_MONTH[dateStartAtMonth]
+                        : exports.LIST_MONTH_SHORT[dateStartAtMonth]) +
+                    ' - ' +
+                    getDateString(endAt, format, formatMonth));
+            }
+        }
+        return (getDateString(startAt, format, formatMonth) +
+            ' - ' +
+            getDateString(endAt, format, formatMonth));
+    }
+    else {
+        return '-';
+    }
+}
+function getDateTimeRangeString(startAt, endAt, format = 'short', formatMonth = 'long') {
+    if (startAt && !endAt) {
+        return getDateTimeString(startAt, format, formatMonth);
+    }
+    else if (!startAt && endAt) {
+        return getDateTimeString(endAt, format, formatMonth);
+    }
+    else if (startAt &&
+        endAt &&
+        new Date(startAt).getTime() === new Date(endAt).getTime()) {
+        return getDateTimeString(startAt, format, formatMonth);
+    }
+    else if (startAt && endAt) {
+        const dateStartAt = new Date(startAt);
+        const dateStartAtYear = dateStartAt.getFullYear();
+        const dateStartAtMonth = dateStartAt.getMonth();
+        const dateStartAtDate = dateStartAt.getDate();
+        const dateEndAt = new Date(endAt);
+        const dateEndAtYear = dateEndAt.getFullYear();
+        const dateEndAtMonth = dateEndAt.getMonth();
+        const dateEndAtDate = dateEndAt.getDate();
+        if (dateStartAtYear === dateEndAtYear) {
+            if (dateStartAtMonth === dateEndAtMonth) {
+                if (dateStartAtDate === dateEndAtDate) {
+                    return (getDateTimeString(startAt, format, formatMonth, {
+                        date: true,
+                        month: true,
+                        year: true,
+                    }) +
+                        ', ' +
+                        getDateTimeString(startAt, format, formatMonth, { time: true }) +
+                        '-' +
+                        getDateTimeString(endAt, format, formatMonth, { time: true }));
+                }
+                else {
+                    return (getDateTimeString(startAt, format, formatMonth) +
+                        ' - ' +
+                        getDateTimeString(endAt, format, formatMonth));
+                }
+            }
+            else {
+                return (getDateTimeString(startAt, format, formatMonth) +
+                    ' - ' +
+                    getDateTimeString(endAt, format, formatMonth));
+            }
+        }
+        return (getDateTimeString(startAt, format, formatMonth) +
+            ' - ' +
+            getDateTimeString(endAt, format, formatMonth));
+    }
+    else {
+        return '-';
+    }
+}
+const toAcceptableApiFormat = (s) => {
+    return s
+        ? new Date(s).toJSON().slice(0, 10).split('-').reverse().join('-')
+        : s;
+};
+exports.toAcceptableApiFormat = toAcceptableApiFormat;
+const getAge = (dateString, base) => {
+    const baseDate = base ? new Date(base) : new Date();
+    const birthDate = dateString ? new Date(dateString) : new Date();
+    let age = baseDate.getFullYear() - birthDate.getFullYear();
+    const m = baseDate.getMonth() - birthDate.getMonth();
+    if (m < 0 || (m === 0 && baseDate.getDate() < birthDate.getDate())) {
+        age--;
+    }
+    return age;
+};
+exports.getAge = getAge;
+const evnDate = (date) => {
+    const cleanDate = date.split(' ')[0];
+    return (0, moment_1.default)(cleanDate).format(cleanDate.split('-')[2] === cleanDate.split('-')[2] &&
+        cleanDate !== cleanDate
+        ? 'MMM D'
+        : 'MMM D YYYY');
+};
+exports.evnDate = evnDate;

package/dist/utils/errorHandler.d.ts

@@ -0,0 +1,17 @@
+export declare function getErrorMessage(err: any, config?: {
+    showFullErrorMessage?: boolean;
+}): string;
+export declare function getErrorCode(err: any): any;
+export declare function getErrors(err: any): any;
+export declare function getStandardError(err: any, config?: {
+    triggerFormValidation?: boolean;
+    formRef?: any;
+    showToast?: boolean;
+    toastFunction?: any;
+    showFullErrorMessage?: boolean;
+}): {
+    message: string | null;
+    code: string | null;
+    errors: any[] | null;
+};
+export declare function handleFormValidation(errors: any[], formRef: any): void;

package/dist/utils/errorHandler.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorMessage = getErrorMessage;
+exports.getErrorCode = getErrorCode;
+exports.getErrors = getErrors;
+exports.getStandardError = getStandardError;
+exports.handleFormValidation = handleFormValidation;
+function getErrorMessage(err, config) {
+    let errMessage = 'Failed. Please try again.';
+    console.info('err', err);
+    if (err && typeof err === 'string') {
+        errMessage = err;
+    }
+    else if (err && err.response) {
+        if (err.response.data && err.response.data.message) {
+            errMessage = err.response.data.message;
+            errMessage = handleAdditionalErrorMessage(errMessage, err.response.data.errors);
+        }
+        else if (err.response.message) {
+            errMessage = err.response.message;
+            errMessage = handleAdditionalErrorMessage(errMessage, err.response.errors);
+        }
+        else {
+            errMessage = JSON.stringify(err);
+        }
+    }
+    else if (err && err.data) {
+        if (err.data && err.data.message) {
+            errMessage = err.data.message;
+            errMessage = handleAdditionalErrorMessage(errMessage, err.data.errors);
+        }
+        else {
+            errMessage = JSON.stringify(err);
+        }
+    }
+    else if (err.message) {
+        errMessage = err.message;
+        errMessage = handleAdditionalErrorMessage(errMessage, err.errors);
+    }
+    else if (err.statusText) {
+        errMessage = err.statusText;
+    }
+    else {
+        errMessage = JSON.stringify(err);
+    }
+    if (!(config === null || config === void 0 ? void 0 : config.showFullErrorMessage) && errMessage.length > 52) {
+        errMessage = errMessage.substring(0, 50) + '...';
+    }
+    return errMessage;
+}
+function handleAdditionalErrorMessage(originalMessage, errors) {
+    if (errors && errors.length > 0) {
+        return `${originalMessage} (${errors
+            .map((error) => error.message)
+            .join(', ')})`;
+    }
+    return originalMessage;
+}
+function getErrorCode(err) {
+    let errorCode;
+    console.info('err', err);
+    if (err && typeof err === 'string') {
+        errorCode = err;
+    }
+    else if (err && err.response) {
+        if (err.response.data && err.response.data.code) {
+            errorCode = err.response.data.code;
+        }
+        else if (err.response.code) {
+            errorCode = err.response.code;
+        }
+        else {
+        }
+    }
+    else if (err && err.data) {
+        if (err.data && err.data.message) {
+        }
+        else {
+        }
+    }
+    else if (err.message) {
+    }
+    else if (err.statusText) {
+    }
+    else {
+    }
+    return errorCode;
+}
+function getErrors(err) {
+    let errors = null;
+    console.info('err', err);
+    if (err && typeof err === 'string') {
+    }
+    else if (err && err.response) {
+        if (err.response.data && err.response.data.errors) {
+            errors = err.response.data.errors;
+        }
+        else if (err.response.errors) {
+            errors = err.response.errors;
+        }
+    }
+    else if (err && err.data) {
+        if (err.data && err.data.errors) {
+            errors = err.data.errors;
+        }
+    }
+    else if (err.errors) {
+        errors = err.errors;
+    }
+    return errors;
+}
+function getStandardError(err, config) {
+    const message = getErrorMessage(err, { showFullErrorMessage: config === null || config === void 0 ? void 0 : config.showFullErrorMessage });
+    const code = getErrorCode(err);
+    const errors = getErrors(err);
+    if (config === null || config === void 0 ? void 0 : config.triggerFormValidation) {
+        handleFormValidation(errors || [], config.formRef);
+    }
+    if ((config === null || config === void 0 ? void 0 : config.showToast) && (config === null || config === void 0 ? void 0 : config.toastFunction)) {
+        config.toastFunction.error(message);
+    }
+    return {
+        code,
+        message,
+        errors,
+    };
+}
+function handleFormValidation(errors, formRef) {
+    if (!formRef)
+        return;
+    if (!errors)
+        return;
+    if (errors.length === 0)
+        return;
+    const fields = [];
+    for (const error of errors) {
+        if (error.path && error.type === 'unique violation') {
+            fields.push({
+                name: error.path,
+                errors: [`${error.value} already exist`],
+            });
+        }
+        else if (error.path) {
+            fields.push({
+                name: error.path,
+                errors: [error.message],
+            });
+        }
+    }
+    if (fields) {
+        formRef.setFields(fields);
+    }
+}

package/dist/utils/formRules.d.ts

@@ -0,0 +1,6 @@
+export type TypeRule = Array<"required" | "email" | "phoneNumber" | "letter-and-space" | "password" | "numeric" | "nik" | "subdomain">;
+export declare function generateFormRules(formName: string, rules: TypeRule): Array<{
+    required?: boolean;
+    message: string;
+    pattern?: any;
+}>;

package/dist/utils/formRules.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFormRules = generateFormRules;
+function generateFormRules(formName, rules) {
+    const formRules = [];
+    if (rules.includes("required")) {
+        formRules.push({
+            required: true,
+            message: `${formName} is required.`,
+        });
+    }
+    if (rules.includes("email")) {
+        formRules.push({
+            pattern: /^(([^<>()[\]\\.,;:\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,}))$/,
+            message: `format ${formName} harus valid.`,
+        });
+    }
+    if (rules.includes("phoneNumber")) {
+        formRules.push({
+            pattern: /^[0-9+ -]+$/,
+            message: `${formName} hanya diisi angka.`,
+        });
+    }
+    if (rules.includes("letter-and-space")) {
+        formRules.push({
+            pattern: /^[a-zA-Z ']+$/,
+            message: `${formName} hanya diisi huruf.`,
+        });
+    }
+    if (rules.includes("password")) {
+        formRules.push({
+            pattern: /^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?.,+-=/;:"<>&])[A-Za-z\d@$!%*#?.,+-=/;:"<>&]{8,}$/,
+            message: `${formName} minimum 8 karakter (huruf, angka and karakter spesial)`,
+        });
+    }
+    if (rules.includes("numeric")) {
+        formRules.push({
+            pattern: /^[0-9]+$/,
+            message: `${formName} hanya diisi angka.`,
+        });
+    }
+    if (rules.includes("nik")) {
+        formRules.push({
+            pattern: /^[0-9]{16}$/,
+            message: `${formName} harus terdiri dari 16 angka.`,
+        });
+    }
+    if (rules.includes("subdomain")) {
+        formRules.push({
+            pattern: /^[0-9a-zA-Z-]+$/,
+            message: `${formName} only contain alphabet, numeric and dash.`,
+        });
+    }
+    return formRules;
+}

package/dist/utils/generateQueryString.d.ts

@@ -0,0 +1 @@
+export declare function generateQueryString(params?: any): string;

package/dist/utils/generateQueryString.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateQueryString = generateQueryString;
+function generateQueryString(params) {
+    if (!params)
+        return '';
+    const query = Object.keys(params)
+        .filter((key) => {
+        if (Array.isArray(params[key])) {
+            return params[key].length > 0;
+        }
+        else {
+            return !!params[key];
+        }
+    })
+        .map((key) => {
+        if (params[key]) {
+            return key + '=' + params[key];
+        }
+        return null;
+    })
+        .join('&');
+    return query && '?' + query;
+}

package/dist/utils/image.d.ts

@@ -0,0 +1,12 @@
+export declare const getFileImageDimension: (file: string | Blob | any) => Promise<{
+    width: number;
+    height: number;
+}>;
+export declare function imageResize(file: File | Blob | any, maxWidth?: number, maxFileSize?: number, originalFileName?: string): Promise<File | Blob>;
+export declare function isImageMoreThanXMB(file: File | Blob, maxFileSize: number): boolean;
+export declare function bytesToMB(sizeInBytes: number): number;
+export declare function isImage(file: File | Blob): any;
+export declare const getBase64: (file: File) => Promise<string>;
+export declare function fileListToBase64(fileList: any[]): Promise<string[]>;
+export declare function getFile(newFile: any): any;
+export declare function isPhotoDataOK(item: any): boolean;

package/dist/utils/image.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBase64 = exports.getFileImageDimension = void 0;
+exports.imageResize = imageResize;
+exports.isImageMoreThanXMB = isImageMoreThanXMB;
+exports.bytesToMB = bytesToMB;
+exports.isImage = isImage;
+exports.fileListToBase64 = fileListToBase64;
+exports.getFile = getFile;
+exports.isPhotoDataOK = isPhotoDataOK;
+const image_blob_reduce_1 = __importDefault(require("image-blob-reduce"));
+const pica_1 = __importDefault(require("pica"));
+const getFileImageDimension = (file) => {
+    return new Promise(async (resolve) => {
+        var fr = new FileReader();
+        fr.onload = function () {
+            var img = new Image();
+            img.onload = function () {
+                resolve({
+                    width: img.width,
+                    height: img.height,
+                });
+            };
+            img.src = fr.result;
+        };
+        fr.readAsDataURL(file);
+    });
+};
+exports.getFileImageDimension = getFileImageDimension;
+async function imageResize(file, maxWidth, maxFileSize, originalFileName) {
+    if (!maxWidth) {
+        maxWidth = 1000;
+    }
+    console.info('original file', file);
+    const pica = (0, pica_1.default)({ features: ['js', 'wasm', 'cib'] });
+    console.info('pica', pica);
+    const reduce = new image_blob_reduce_1.default({ pica });
+    console.info('reduce', reduce);
+    let res = await reduce.toBlob(file, {
+        max: maxWidth !== null && maxWidth !== void 0 ? maxWidth : 1000,
+    });
+    console.info('res', res);
+    const resFile = new File([res], file.name ||
+        file.name ||
+        originalFileName ||
+        'compressed_image');
+    console.info('resFile', resFile);
+    console.info('resFile.type', resFile.type);
+    if (isImageMoreThanXMB(resFile, maxFileSize ? maxFileSize : 2)) {
+        console.info('resizing again... width: ' + (maxWidth - 100), resFile);
+        return imageResize(resFile, maxWidth - 100, maxFileSize, file.name || file.name || 'compressed_image');
+    }
+    return resFile;
+}
+function isImageMoreThanXMB(file, maxFileSize) {
+    console.info('isImageMoreThanXMB', file);
+    console.info('isImageMoreThanXMB - size', file.size);
+    console.info('isImageMoreThanXMB - maxFileSize', maxFileSize);
+    const res = (file.size || 0) / 1024 / 1024 > maxFileSize;
+    console.info('isImageMoreThanXMB - res', res);
+    return res;
+}
+function bytesToMB(sizeInBytes) {
+    return Math.ceil(sizeInBytes / 1024 / 1024);
+}
+function isImage(file) {
+    var _a, _b, _c, _d, _e, _f;
+    return (file.type === 'image/png' ||
+        file.type === 'image/jpeg' ||
+        ((_a = file.name) === null || _a === void 0 ? void 0 : _a.toLowerCase().endsWith('.png')) ||
+        ((_b = file.name) === null || _b === void 0 ? void 0 : _b.toLowerCase().endsWith('.jpg')) ||
+        ((_c = file.name) === null || _c === void 0 ? void 0 : _c.toLowerCase().endsWith('.jpeg')) ||
+        file.mimeType === 'image/png' ||
+        file.mimeType === 'image/jpeg' ||
+        ((_d = file.originalName) === null || _d === void 0 ? void 0 : _d.toLowerCase().endsWith('.png')) ||
+        ((_e = file.originalName) === null || _e === void 0 ? void 0 : _e.toLowerCase().endsWith('.jpg')) ||
+        ((_f = file.originalName) === null || _f === void 0 ? void 0 : _f.toLowerCase().endsWith('.jpeg')) ||
+        !!file.thumbUrl);
+}
+const getBase64 = (file) => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = (error) => reject(error);
+});
+exports.getBase64 = getBase64;
+async function fileListToBase64(fileList) {
+    const promises = [];
+    for (let i = 0; i < fileList.length; i++) {
+        const file = getFile(fileList[i]);
+        if (file) {
+            promises.push((0, exports.getBase64)(file));
+        }
+        else {
+            promises.push(new Promise((resolve) => {
+                resolve(fileList[i].url);
+            }));
+        }
+    }
+    return (await Promise.all(promises));
+}
+function getFile(newFile) {
+    if (isImage(newFile) && newFile.originFileObj) {
+        return newFile.originFileObj;
+    }
+    else {
+        return null;
+    }
+}
+function isPhotoDataOK(item) {
+    if (typeof item === 'object') {
+        if (item.error) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    else {
+        return false;
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from './auth';
+export * from './datetime';
+export * from './errorHandler';
+export * from './formRules';
+export * from './generateQueryString';
+export * from './image';
+export * from './name';
+export * from './order';
+export * from './pagination';
+export * from './price';
+export * from './text';

package/dist/utils/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./auth"), exports);
+__exportStar(require("./datetime"), exports);
+__exportStar(require("./errorHandler"), exports);
+__exportStar(require("./formRules"), exports);
+__exportStar(require("./generateQueryString"), exports);
+__exportStar(require("./image"), exports);
+__exportStar(require("./name"), exports);
+__exportStar(require("./order"), exports);
+__exportStar(require("./pagination"), exports);
+__exportStar(require("./price"), exports);
+__exportStar(require("./text"), exports);

package/dist/utils/name.d.ts

@@ -0,0 +1,6 @@
+export declare const getInitialName: (name: string) => string;
+export declare const generateFullName: (names: {
+    firstName?: string;
+    middleName?: string;
+    lastName?: string;
+}) => string;

package/dist/utils/name.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFullName = exports.getInitialName = void 0;
+const getInitialName = (name) => {
+    const split = name.split(' ');
+    let start = 0;
+    let initial = [];
+    if (split.length > 1) {
+        while (start <= 1) {
+            initial.push(split[start].charAt(0));
+            start++;
+        }
+    }
+    else {
+        initial.push(split[0].substring(0, 2));
+    }
+    return initial.join('').toUpperCase();
+};
+exports.getInitialName = getInitialName;
+const generateFullName = (names) => {
+    let concated = [];
+    if (names.firstName) {
+        concated.push(names.firstName);
+    }
+    if (names.middleName) {
+        concated.push(names.middleName);
+    }
+    if (names.lastName) {
+        concated.push(names.lastName);
+    }
+    return concated.join(' ');
+};
+exports.generateFullName = generateFullName;

package/dist/utils/order.d.ts

@@ -0,0 +1 @@
+export declare function calculateAddDayForFirstOrder(): number;

package/dist/utils/order.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAddDayForFirstOrder = calculateAddDayForFirstOrder;
+function calculateAddDayForFirstOrder() {
+    let addDay = 1;
+    const now = new Date();
+    if (now.getHours() > 12) {
+        addDay = 2;
+    }
+    else if (now.getHours() === 12) {
+        if (now.getMinutes() > 0) {
+            addDay = 2;
+        }
+    }
+    return addDay;
+}

package/dist/utils/pagination.d.ts

@@ -0,0 +1,29 @@
+export declare const PAGE_SIZE_OPTIONS: string[];
+export type IPagination = {
+    page: number;
+    perPage: number;
+    totalData: number;
+    countPage: number;
+    prev: string;
+    next: string;
+};
+export declare const INITIAL_PAGINATION: IPagination;
+export type IQuery = {
+    offset?: number;
+    limit?: number;
+};
+export declare const INITIAL_QUERY: {
+    offset: number;
+    limit: number;
+};
+export type IPayloadPagination<ResultItem> = {
+    next: string;
+    prev: string;
+    count: number;
+    results: Array<ResultItem>;
+};
+export interface IHttpResponse<Payload> {
+    code: string;
+    message: string;
+    payload: Payload;
+}

package/dist/utils/pagination.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INITIAL_QUERY = exports.INITIAL_PAGINATION = exports.PAGE_SIZE_OPTIONS = void 0;
+exports.PAGE_SIZE_OPTIONS = ['10', '20', '50'];
+exports.INITIAL_PAGINATION = {
+    page: 1,
+    perPage: 25,
+    totalData: 0,
+    countPage: 1,
+    next: '',
+    prev: '',
+};
+exports.INITIAL_QUERY = {
+    offset: 0,
+    limit: 25,
+};

package/dist/utils/price.d.ts

@@ -0,0 +1,5 @@
+export declare function formatCurrency(amount: number, currencySymbol?: string, thousandSep?: string, decimalSep?: string, showDecimal?: boolean): string;
+export declare function formatCurrencyIndonesia(amount: number): string;
+export declare function formatCurrencyRangeIndonesia(amountStart: number, amountEnd?: number): string;
+export declare function parseCurrency(currencyString: string, thousandSep?: string, decimalSep?: string): number;
+export default function thousandSeparator(x: number | string): string;

package/dist/utils/price.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCurrency = formatCurrency;
+exports.formatCurrencyIndonesia = formatCurrencyIndonesia;
+exports.formatCurrencyRangeIndonesia = formatCurrencyRangeIndonesia;
+exports.parseCurrency = parseCurrency;
+exports.default = thousandSeparator;
+function formatCurrency(amount, currencySymbol = '$', thousandSep = ',', decimalSep = '.', showDecimal = true) {
+    console.info('formatCurrency', amount);
+    if (typeof amount === 'string')
+        amount = Number(amount);
+    if (!amount)
+        amount = 0;
+    const [intPart, decPart] = amount.toFixed(2).split('.');
+    let intPartWithSep = '';
+    for (let i = intPart.length - 1, j = 0; i >= 0; i--, j++) {
+        if (j > 0 && j % 3 === 0) {
+            intPartWithSep = thousandSep + intPartWithSep;
+        }
+        intPartWithSep = intPart[i] + intPartWithSep;
+    }
+    return currencySymbol + intPartWithSep + (showDecimal ? decimalSep + decPart : '');
+}
+function formatCurrencyIndonesia(amount) {
+    return formatCurrency(amount, 'Rp', '.', ',', false);
+}
+function formatCurrencyRangeIndonesia(amountStart, amountEnd) {
+    if (amountStart === amountEnd) {
+        return formatCurrencyIndonesia(amountStart);
+    }
+    else if (amountStart && amountEnd) {
+        return (formatCurrencyIndonesia(amountStart) +
+            ' - ' +
+            formatCurrencyIndonesia(amountEnd));
+    }
+    else if (amountStart) {
+        return formatCurrencyIndonesia(amountStart) + ' - unlimited';
+    }
+    else if (amountEnd) {
+        return 'up to ' + formatCurrencyIndonesia(amountEnd);
+    }
+    else {
+        return '';
+    }
+}
+function parseCurrency(currencyString, thousandSep = ',', decimalSep = '.') {
+    if (!currencyString)
+        currencyString = '';
+    const cleanedString = thousandSep === ','
+        ? currencyString.replace(/[^\d.-]/g, '')
+        : currencyString.replace(/[^\d,-]/g, '');
+    const [intPart, decPart] = cleanedString.split(decimalSep);
+    const numberWithDecimal = intPart + (decPart ? decimalSep + decPart : '');
+    return parseFloat(numberWithDecimal);
+}
+function thousandSeparator(x) {
+    return x && (x === null || x === void 0 ? void 0 : x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, '.'));
+}

package/dist/utils/text.d.ts

@@ -0,0 +1,15 @@
+export declare function capitalizeFirstLetter(text: string): string;
+export type ReadableTextConfig = {
+    style?: 'lowercase' | 'uppercase' | 'capital-first-word';
+    disableUnderscoreToSpace?: boolean;
+    disableDashToSpace?: boolean;
+};
+export declare function showReadableText(str: string, config?: ReadableTextConfig): string;
+export declare function convertHtmlToText(htmlText: string): string;
+export declare function convertSlugToText(slug: string): string;
+export declare function convertTextToRupiah(text: string): string;
+export declare function exportToCamelCase(str: string): string;
+export declare const getYouTubeId: (url?: string) => string;
+export declare function limitDescription(text: any, limit?: number): any;
+export declare function replaceDashWithSpace(word: string): string;
+export declare function replaceUnderscoreWithSpace(word: string): string;

package/dist/utils/text.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getYouTubeId = void 0;
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+exports.showReadableText = showReadableText;
+exports.convertHtmlToText = convertHtmlToText;
+exports.convertSlugToText = convertSlugToText;
+exports.convertTextToRupiah = convertTextToRupiah;
+exports.exportToCamelCase = exportToCamelCase;
+exports.limitDescription = limitDescription;
+exports.replaceDashWithSpace = replaceDashWithSpace;
+exports.replaceUnderscoreWithSpace = replaceUnderscoreWithSpace;
+const price_1 = __importDefault(require("./price"));
+function capitalizeFirstLetter(text) {
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+function showReadableText(str, config) {
+    var _a, _b;
+    if (!str) {
+        return '';
+    }
+    if (!(config && config.disableDashToSpace)) {
+        str = replaceDashWithSpace(str);
+    }
+    if (!(config && config.disableUnderscoreToSpace)) {
+        str = str.replace(/_/g, ' ');
+    }
+    if (config && config.style === 'lowercase') {
+        str = str.toLowerCase();
+    }
+    else if (config && config.style === 'uppercase') {
+        str = str.toUpperCase();
+    }
+    else {
+        str = ((_a = str.charAt(0)) === null || _a === void 0 ? void 0 : _a.toUpperCase()) + ((_b = str.toLowerCase()) === null || _b === void 0 ? void 0 : _b.slice(1));
+    }
+    return str;
+}
+function convertHtmlToText(htmlText) {
+    return htmlText.replace(/<[^>]+>/g, " ");
+}
+function convertSlugToText(slug) {
+    let text = slug.split("-").join(" ");
+    return capitalizeFirstLetter(text);
+}
+function convertTextToRupiah(text) {
+    return `Rp ${(0, price_1.default)(text)}`;
+}
+function exportToCamelCase(str) {
+    return str
+        .replace(/(?:^\w|[A-Z]|\b\w)/g, function (word, index) {
+        return index == 0 ? word.toLowerCase() : word.toUpperCase();
+    })
+        .replace(/\s+/g, "");
+}
+const getYouTubeId = (url) => {
+    if (!url)
+        return undefined;
+    let match = url.match(/^((?:https?:)?\/\/)?((?:www|m)\.)?((?:youtube(-nocookie)?\.com|youtu.be))(\/(?:[\w-]+\?v=|embed\/|v\/)?)([\w-]+)(\S+)?$/);
+    return match === null || match === void 0 ? void 0 : match[6];
+};
+exports.getYouTubeId = getYouTubeId;
+function limitDescription(text, limit = 200) {
+    const words = text.split(" ");
+    if (words.length > limit) {
+        const truncatedWords = words.slice(0, limit);
+        const truncatedText = truncatedWords.join(" ") + "...";
+        return truncatedText;
+    }
+    return text;
+}
+function replaceDashWithSpace(word) {
+    const splitter = word.split('-');
+    let wordReturn = '';
+    splitter.map((word) => {
+        const lower = word.toLowerCase().slice(1);
+        const capital = word.charAt(0).toUpperCase();
+        wordReturn = wordReturn + ` ${capital}${lower}`;
+    });
+    return wordReturn;
+}
+function replaceUnderscoreWithSpace(word) {
+    const splitter = word.split(/[ ,_]+/);
+    let wordReturn = '';
+    splitter.map((word) => {
+        const lower = word.toLowerCase().slice(1);
+        const capital = word.charAt(0).toUpperCase();
+        wordReturn = wordReturn + ` ${capital}${lower}`;
+    });
+    return wordReturn;
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@qlibs/utils",
+  "version": "1.0.2",
+  "description": "",
+  "author": "QBIT Developer",
+  "license": "MIT",
+  "url": "https://github.com/qbit-tech/qlibs-utils",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "scripts": {
+    "build": "rimraf -rf dist && tsc -p tsconfig.json",
+    "format": "prettier --write \"**/*.ts\"",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "start": "craco start",
+    "prepublish:npm": "npm run build",
+    "publish:npm": "npm publish --access public",
+    "prepublish:next": "npm run build",
+    "publish:next": "npm publish --access public --tag next",
+    "test:e2e": "jest --config ./tests/jest-e2e.json --runInBand",
+    "prerelease": "npm run build",
+    "release": "release-it",
+    "prepare": "husky install && npm run build"
+  },
+  "dependencies": {
+    "husky": "^8.0.3",
+    "image-blob-reduce": "^4.1.0",
+    "immutability-helper": "^3.1.1",
+    "moment": "^2.30.1",
+    "pica": "^9.0.1",
+    "release-it": "16.1.5",
+    "rimraf": "5.0.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.2"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  }
+}