cortex-react-ui 0.1.182 → 0.2.1

package/lib/cjs/{types/BarLoader → BarLoader}/BarLoader.d.ts

@@ -3,7 +3,6 @@ export interface BarLoaderProps {
     title?: string;
     color?: 'red' | 'blue' | 'yellow' | 'orange' | 'green';
     className?: string;
-    mode: 'determinate' | 'indeterminate';
     isComplete: boolean;
 }
 declare const BarLoader: React.FC<BarLoaderProps>;

package/lib/cjs/{types/Camera → Camera}/Camera.d.ts

@@ -1,14 +1,16 @@
+/// <reference types="react" />
 import { WebcamProps } from 'react-webcam';
-declare const Camera: ({ onCapture, isOffline, mode, validateText, resetText, isShowOffline, ...props }: CameraProps) => JSX.Element;
-export declare type CameraProps = {
+declare const Camera: React.FC<CameraProps>;
+export type CameraProps = {
     onCapture: ({ fileStoreName, fileRowId, file }: TfileCapturedProps) => void;
     mode?: 'photo' | 'video';
     isOffline?: boolean;
     isShowOffline?: boolean;
     validateText?: string;
     resetText?: string;
+    isShowVideoButton?: boolean;
 } & Partial<WebcamProps>;
-export declare type TfileCapturedProps = {
+export type TfileCapturedProps = {
     fileStoreName?: string | null;
     fileRowId?: number | null;
     file?: File | null;

package/lib/{esm/types → cjs}/DatePicker/DatePicker.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-declare type Props = {
+type Props = {
     value?: Date;
     className?: string;
 };

package/lib/cjs/{types/DomContainer → DomContainer}/DomContainer.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-declare type Props = {
+type Props = {
     children?: React.ReactNode;
     container?: HTMLElement | (() => HTMLElement);
 };

package/lib/cjs/Map/App.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { MapsProps } from './components/Maps';
+import 'leaflet/dist/leaflet.css';
+import 'leaflet-draw/dist/leaflet.draw.css';
+import { Point } from './models';
+declare const App: React.FC<AppProps>;
+export type AppProps = MapsProps & {
+    onClose: (() => void);
+    onSave: ((points: Point[]) => void);
+    customButtons?: {
+        cancelButton?: HTMLElement;
+        saveButton?: HTMLElement;
+    };
+};
+export default App;

package/lib/cjs/Map/Map.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { MapsProps } from './components/Maps';
+import 'leaflet/dist/leaflet.css';
+import 'leaflet-draw/dist/leaflet.draw.css';
+import { Point } from './models';
+declare const Map: React.FC<AppProps>;
+export type AppProps = MapsProps & {
+    onClose: (() => void);
+    onSave: ((points: Point[]) => void);
+    customButtons?: {
+        cancelButton?: HTMLElement;
+        saveButton?: HTMLElement;
+    };
+};
+export default Map;

package/lib/cjs/Map/components/CenterActiveAreaControl.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare const CenterActiveAreaControl: React.FC<CenterActiveAreaControlProps>;
+export type CenterActiveAreaControlProps = {
+    autoCenter?: boolean;
+};

package/lib/cjs/Map/components/DrawTools.d.ts

@@ -0,0 +1,16 @@
+import { ControlPosition } from 'leaflet';
+export declare const DrawTools: (props: DrawToolsProps) => import("react/jsx-runtime").JSX.Element;
+export type DrawToolsProps = {
+    position?: ControlPosition | undefined;
+    handleOnCreated?: (v: void) => void;
+    handleOnDeleted?: (v: void) => void;
+    draw?: drawType;
+};
+export type drawType = {
+    polyline?: boolean;
+    polygon?: boolean;
+    rectangle?: boolean;
+    circle?: boolean;
+    marker?: boolean;
+    circlemarker?: boolean;
+};

package/lib/cjs/Map/components/LocationContext.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { Location } from '../models';
+export type LocationContent = {
+    locations: Location[];
+    setLocations: React.Dispatch<React.SetStateAction<Location[]>>;
+};
+export declare const LocationContext: import("react").Context<LocationContent>;

package/lib/cjs/Map/components/MapFullscreenControl.d.ts

@@ -0,0 +1,22 @@
+import 'leaflet.fullscreen/Control.FullScreen.css';
+import { ControlPosition } from 'leaflet';
+export declare const MapFullscreenControl: (props: MapFullscreenControlProps) => import("react/jsx-runtime").JSX.Element;
+/** Props interface for MapFullscreenControl component */
+export type MapFullscreenControlProps = {
+    /** Change the content of the button, can be HTML, default null */
+    content?: string | undefined;
+    /** Change the position of the button can be topleft, topright, bottomright or bottomleft, default topleft */
+    position?: ControlPosition | undefined;
+    /** Change the title of the button, default Full Screen */
+    title?: string | undefined;
+    /** Change the title of the button when fullscreen is on, default Exit Full Screen */
+    titleCancel?: string | undefined;
+    /** Force separate button to detach from zoom buttons, default false */
+    forceSeparateButton?: boolean | undefined;
+    /** Force use of pseudo full screen even if full screen API is available, default false */
+    forcePseudoFullscreen?: boolean | undefined;
+    /** Use pseudo fullscreen */
+    pseudoFullscreen?: boolean | undefined;
+    /** Dom element to render in full screen, false by default, fallback to map._container */
+    fullscreenElement?: false | HTMLElement | undefined;
+};

package/lib/cjs/Map/components/Maps.d.ts

@@ -0,0 +1,19 @@
+import { MapContainerProps } from 'react-leaflet';
+import { LatLngTuple } from 'leaflet';
+import { Location } from '../models';
+import { CenterActiveAreaControlProps } from './CenterActiveAreaControl';
+import { MapFullscreenControlProps } from './MapFullscreenControl';
+import { DrawToolsProps } from './DrawTools';
+declare const Maps: (props: MapsProps) => import("react/jsx-runtime").JSX.Element;
+export type MapsProps = {
+    MapContainerProps?: MapContainerProps;
+    center?: LatLngTuple;
+    fullscreen?: MapFullscreenControlProps | boolean;
+    centerActiveArea?: CenterActiveAreaControlProps | boolean;
+    drawTools?: DrawToolsProps | boolean;
+    minZoom?: number;
+    maxZoom?: number;
+    zoom?: number;
+    data?: Location[];
+};
+export default Maps;

package/lib/cjs/Map/config/appConfig.d.ts

@@ -0,0 +1,4 @@
+export default class AppConfig {
+    prod: boolean;
+    apiUrl: string;
+}

package/lib/cjs/Map/config/config.d.ts

@@ -0,0 +1,6 @@
+import AppConfig from './appConfig';
+declare class Config extends AppConfig {
+    constructor();
+}
+declare const _default: Config;
+export default _default;

package/lib/cjs/Map/hooks/getGeoJSONTest.d.ts

@@ -0,0 +1,16 @@
+export declare const getGeoJSONTest: () => {
+    type: string;
+    features: {
+        type: string;
+        properties: {
+            "marker-color": string;
+            "marker-size": string;
+            "marker-symbol": string;
+            description: string;
+        };
+        geometry: {
+            type: string;
+            coordinates: number[];
+        };
+    }[];
+};

package/lib/cjs/Map/hooks/useLocationContext.d.ts

@@ -0,0 +1 @@
+export declare const useLocationContext: () => import("../components/LocationContext").LocationContent;

package/lib/cjs/Map/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Map';

package/lib/cjs/Map/models/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Location } from './location';
+export { default as Point } from './point';

package/lib/cjs/Map/models/location.d.ts

@@ -0,0 +1,6 @@
+import Point from "./point";
+export default class Location {
+    id: number;
+    objId: string;
+    points: Point[];
+}

package/lib/cjs/Map/models/locationSearch.d.ts

@@ -0,0 +1,4 @@
+export default class LocationSearch {
+    objId: string[];
+    type: string;
+}

package/lib/cjs/Map/models/point.d.ts

@@ -0,0 +1,6 @@
+export default class Point {
+    id: number;
+    order: number;
+    latitude: number;
+    longitude: number;
+}

package/lib/cjs/Map/utils/logger.d.ts

@@ -0,0 +1,17 @@
+interface LogOptions {
+    tags?: string[];
+    context?: any;
+    method?: Function | string;
+}
+export declare enum LogLevel {
+    Info = 0,
+    Warning = 1,
+    Error = 2
+}
+declare class Logger {
+    info(msg: any | any[], options?: LogOptions): void;
+    warn(msg: any | any[], options?: LogOptions): void;
+    error(msg: any | any[], options?: LogOptions): void;
+}
+declare const _default: Logger;
+export default _default;

package/lib/cjs/Map/utils/toolkit.d.ts

@@ -0,0 +1,129 @@
+interface MapOptions {
+    transformIsoToDate?: boolean;
+    strictMapping?: boolean;
+    ignoreStrictMappingWhenNull?: boolean;
+}
+interface DiffOptions {
+    objectKey?: string;
+    predicate?: (item: any, array: any[]) => boolean;
+    format?: (item: any) => any;
+    alternativeFormat?: (item: any) => any;
+}
+export default class ToolKit {
+    /**
+     * Type checks
+     */
+    static isEmailFormat(email: string): boolean;
+    static isDefined<T>(arg: T): arg is NonNullable<T>;
+    static isObject(arg: any): arg is Object;
+    static isString(arg: any): arg is string;
+    static isFunction(arg: any): arg is Function;
+    static isArray(arg: any): arg is any[];
+    static isBoolean(arg: any): arg is boolean;
+    static isNumber(arg: any): arg is number;
+    static isValidNumber(arg: any): arg is number;
+    static isNaN(arg: any): boolean;
+    static isFloat(value: number): boolean;
+    static isDate(arg: any): arg is Date;
+    static isValidDate(arg: any): arg is Date;
+    static hasValue(arg: any): boolean;
+    static isUndefined(arg: any): arg is undefined;
+    static isNull(arg: any): arg is null;
+    static isUndefinedOrNull(arg: any): arg is undefined | null;
+    static isNativeTypeObject(arg: any): boolean;
+    static isEmpty<T extends string | any[]>(arg: T): boolean;
+    static noop(): void;
+    /**
+   * Array
+   */
+    static take<T>(array: T[], count: number, from?: number): T[];
+    static addRange(src: any[], newElements: any[]): void;
+    static removeFromCollection<T>(array: T[], predicate: (item: T, index: number) => boolean): boolean;
+    static removeAt<T>(array: T[], index: number): boolean;
+    static replaceAt<T>(array: T[], index: number, item: T): void;
+    static replaceCollectionItem<T>(array: T[], item: T, predicate: (item: T, index: number) => boolean): void;
+    static clearCollection(collection: any[]): void;
+    static diffCollection(array: any[], values: any[], options?: DiffOptions): any[];
+    static findIndex<T>(array: T[], predicate: (item: T, index: number) => boolean): number;
+    static find<T>(array: T[], predicate: (item: T, index: number) => boolean): T | null;
+    static orderBy<T>(array: T[], propertyAccessor: string, options?: {
+        nullFirst?: boolean;
+        ascending?: boolean;
+    }): void;
+    static countCollection<T>(array: T[], predicate: (item: T, index: number) => boolean): number;
+    static isCollectionOf<T = any>(array: T[], instanceOf: any): boolean;
+    /**
+   * String
+   */
+    static fixedLenInteger(value: number, length: number): string;
+    static fixedLenString(value: string, length: number): string;
+    static toCamelCase(value: string): string;
+    static capitalize(value: string): string;
+    /**
+   * Number
+   */
+    static randomNumber(minValue: number, maxValue: number): number;
+    /**
+   * Date
+   */
+    static dateOnly(date: Date): Date;
+    static formatDateTime(date: Date, timezone?: string): string;
+    static formatDateTimeUTC: (date: Date) => string;
+    static formatDateUTC: (date: Date, customFn?: (year: string, month: string, day: string) => string) => string;
+    static formatDate: (date: Date, customFn?: (year: string, month: string, day: string) => string) => string;
+    static formatHourUTC: (value: Date | number, customFn?: (h: string, m: string, s: string) => string) => string;
+    static formatHour: (value: Date | number, customFn?: (h: string, m: string, s: string) => string) => string;
+    static parseDateUTC(input: string): Date | null;
+    static parseDate(input: string): Date | null;
+    static parseHour(input: string): Date | null;
+    static mergeDateAndTime(date: Date, time: Date): Date | null;
+    static safeParseIsoDate<T>(value: T): Date | T;
+    static safeParseDate<T>(value: T): Date | T;
+    static safeParseUTCDate<T>(value: T): Date | T;
+    /**
+   * Classes
+   */
+    static getClassName(instance: any): string | null;
+    static getClassMethodName(instance: any, method: Function): string | null;
+    static className(...args: any[]): string | undefined;
+    /**
+   * Utilities
+   */
+    static getObjectKeysDeep(object: any, prefix?: string): string[];
+    static mapToShallowObject(target: any, src: any, filterPredicate?: (key: string, value: any) => boolean): void;
+    static mapToDeepObject(target: any, src: any, options?: MapOptions): void;
+    static getPropertySafe(obj: any, propertyAccessor: string): any | undefined;
+    static cast<T = any>(arg: any): T;
+    static safeJsonReplacer(_key: any, value: any): any;
+    static safeJsonReviver(_key: any, value: any): any;
+    static quickClone<T>(arg: T): T | null;
+    static hasProperty(obj: any, prop: string | number): boolean;
+    static pureObjectAssign(...values: any[]): any | null;
+    static getTimezones(): Record<string, {
+        utc: number;
+        dst: number;
+        code: string;
+    }>;
+}
+declare global {
+    interface Date {
+        updateTime(time: Date): void;
+        updateDate(date: Date): void;
+        isDstObserved(): boolean;
+        stdTimezoneOffset(): number;
+        toTimezone(timezone: string): Date;
+        getTimezones(): Record<string, {
+            u: number;
+            d: number;
+            c: string;
+        }>;
+    }
+}
+export declare const removeFromCollection: <T>(array: T[], predicate: (item: T, index: number) => boolean) => boolean;
+type ObserverCallback<T> = (data: T) => unknown;
+export declare class Observer<T extends any = any, CallbackType extends Function = ObserverCallback<T>> {
+    protected subscribers: CallbackType[];
+    subscribe(callback: CallbackType): () => void;
+    notify(data: T): void;
+}
+export {};

package/lib/cjs/{types/Menu → Menu}/index.d.ts

@@ -1,4 +1,4 @@
-export { default } from './Menu';
+export { default as Menu } from './Menu';
 export { default as AuthDownloadLink } from './AuthDownloadLink';
 export { default as ContextMenu } from './ContextMenu';
 export { default as MenuItem } from './MenuItem';

package/lib/cjs/{types/Popper → Popper}/Popper.d.ts

@@ -14,7 +14,7 @@ export declare const PopperPlacement: {
     readonly RightBottom: "right-bottom";
     readonly RightCenter: "right-center";
 };
-declare type Props = {
+type Props = {
     anchorEl?: string | HTMLElement | React.RefObject<HTMLElement>;
     anchorPosition?: {
         top: number;

package/lib/cjs/Scanner/Dialog.d.ts

@@ -0,0 +1,8 @@
+export declare const Dialog: (props: DialogProps) => import("react/jsx-runtime").JSX.Element;
+export type DialogTitleProps = {
+    title?: string;
+};
+export type DialogProps = DialogTitleProps & {
+    open: boolean;
+    onClose?: () => void;
+};

package/lib/cjs/Scanner/DialogBody.d.ts

@@ -0,0 +1,3 @@
+import React, { HTMLAttributes } from 'react';
+export declare const DialogBody: React.FC<DialogBodyProps>;
+export type DialogBodyProps = HTMLAttributes<HTMLDivElement>;

package/lib/cjs/Scanner/DialogMask.d.ts

@@ -0,0 +1,3 @@
+import { HTMLAttributes } from 'react';
+export declare const DialogMask: (props: DialogMaskProps) => import("react/jsx-runtime").JSX.Element;
+export type DialogMaskProps = HTMLAttributes<HTMLDivElement>;

package/lib/{esm/types → cjs}/Scanner/ScanConfirmationDialog.d.ts

@@ -1,5 +1,6 @@
-export declare const ScanConfirmationDialog: (props: TScanConfirmDialogProps) => JSX.Element;
-export declare type TScanConfirmDialogLabels = {
+/// <reference types="react" />
+export declare const ScanConfirmationDialog: React.FC<TScanConfirmDialogProps>;
+export type TScanConfirmDialogLabels = {
     title?: string;
     message?: string;
     btnOk?: {
@@ -11,7 +12,7 @@ export declare type TScanConfirmDialogLabels = {
         style?: React.CSSProperties;
     };
 };
-export declare type TScanConfirmDialogProps = {
+export type TScanConfirmDialogProps = {
     open: boolean;
     onConfirm: () => void;
     onClose: () => void;

package/lib/cjs/{types/Scanner → Scanner}/Scanner.d.ts

@@ -1,8 +1,9 @@
+/// <reference types="react" />
 import { IDetectedBarcode, IScannerProps } from '@yudiel/react-qr-scanner';
 import { TScanConfirmDialogLabels } from './ScanConfirmationDialog';
-declare const Scanner: ({ scanConfirmation, scanTrackerType, ...props }: ScannerProps) => JSX.Element;
-export declare type TScanTrackerType = 'outline' | 'boundingBox' | 'centerText';
-declare type ScannerProps = {
+declare const Scanner: React.FC<ScannerProps>;
+export type TScanTrackerType = 'outline' | 'boundingBox' | 'centerText';
+type ScannerProps = {
     scanConfirmation?: boolean;
     scanConfirmDialog?: TScanConfirmDialogLabels;
     scanTrackerType?: TScanTrackerType;

package/lib/{esm/types → cjs}/Transition/CSSTransition.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-declare type Props = {
+type Props = {
     trigger: boolean;
     mode: 'appear' | 'disappear';
     children?: React.ReactElement<any>;

package/lib/cjs/{types/Transition → Transition}/Fade.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-declare type Props = {
+type Props = {
     trigger: boolean;
     children?: React.ReactElement<any>;
     onEnter?: () => void;

package/lib/cjs/{types/index.d.ts → index.d.ts}

@@ -9,6 +9,13 @@ export { default as Camera } from './Camera';
 export { default as ToggleButton } from './ToggleButton';
 export { default as Tooltip } from './Tooltip';
 export { default as TagInput } from './TagInput';
-export { default as Menu, ContextMenu, Divider, MenuItem, PopupMenu, MenuGroup, AuthDownloadLink } from './Menu';
+export { default as Map } from './Map';
+export { default as Menu } from './Menu/Menu';
+export { default as ContextMenu } from './Menu/ContextMenu';
+export { default as Divider } from './Menu/Divider';
+export { default as MenuItem } from './Menu/MenuItem';
+export { default as PopupMenu } from './Menu/PopupMenu';
+export { default as MenuGroup } from './Menu/MenuGroup';
+export { default as AuthDownloadLink } from './Menu/AuthDownloadLink';
 export { default as Dialog, DialogContent, DialogHeader, DialogFooter, ConfirmDialog, ErrorDialog, WarningDialog, DialogActions, DialogTitle } from './Dialog';
 export { ChevronDownIcon, ChevronRightIcon, ChevronLeftIcon, CrossIcon } from './Icons';