ados-rcm 1.0.4 → 1.0.6

package/dist/AModule/AComponents/ATable/ATable.d.ts

@@ -0,0 +1,155 @@
+import { TCBAble } from '../../AUtils/cbF';
+import { IItem } from '../../AUtils/objF';
+import { TIdx } from '../ATypes/ATypes';
+import React from 'react';
+import { TUseValues } from '../../AHooks/useValues';
+import { Resources } from '../AResource/AResource';
+export interface IATableTHProps<T extends IItem> {
+    defKey: TIdx;
+    def: IATableDef<T>;
+}
+export interface IATableTRProps<T extends IItem> {
+    item: T;
+}
+export interface IATableTDProps<T extends IItem> extends IATableTHProps<T>, IATableTRProps<T> {
+}
+export interface IATableDef<T extends IItem> {
+    width?: TCBAble<IATableTHProps<T>, number>;
+    maxWidth?: TCBAble<IATableTHProps<T>, number>;
+    minWidth?: TCBAble<IATableTHProps<T>, number>;
+    align?: TCBAble<IATableTHProps<T>, React.CSSProperties['justifyContent']>;
+    colSpan?: TCBAble<IATableTHProps<T>, number>;
+    hContent?: TCBAble<IATableTHProps<T>, React.ReactNode>;
+    hColor?: TCBAble<IATableTHProps<T>, React.CSSProperties['color']>;
+    hBackgroundColor?: TCBAble<IATableTHProps<T>, React.CSSProperties['backgroundColor']>;
+    isSortable?: boolean;
+    noResize?: boolean;
+    sortF?: (a: T, b: T) => number;
+    content?: TCBAble<IATableTDProps<T>, React.ReactNode>;
+    asText?: TCBAble<IATableTDProps<T>, string | number>;
+    color?: TCBAble<IATableTDProps<T>, React.CSSProperties['color']>;
+    backgroundColor?: TCBAble<IATableTDProps<T>, React.CSSProperties['backgroundColor']>;
+}
+export type TATableDefs<T extends IItem> = {
+    [key in Exclude<keyof T, symbol>]?: IATableDef<T>;
+} & {
+    [key: TIdx]: IATableDef<T>;
+};
+export type TATableFilterType = 'String' | 'Select' | 'Date' | 'DateRange';
+export interface IATableFilterDef<T extends IItem> {
+    String: {
+        type: 'String';
+        defKey?: keyof T | '';
+        predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['String']) => any;
+        placeholder?: string;
+    };
+    Select: {
+        type: 'Select';
+        defKey?: keyof T | '';
+        options: (string | number)[];
+        placeHolder?: string;
+        OptionRenderer?: (option: string | number) => React.ReactNode;
+        predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Select']) => any;
+    };
+    Date: {
+        type: 'Date';
+        defKey?: keyof T | '';
+        minDate?: Date;
+        maxDate?: Date;
+        predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Date']) => any;
+    };
+    DateRange: {
+        type: 'DateRange';
+        defKey?: keyof T | '';
+        minDate?: Date;
+        maxDate?: Date;
+        predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['DateRange']) => any;
+    };
+}
+export type TATableFilterationDefs<T extends IItem> = {
+    type: 'And' | 'Or';
+    defs: IATableFilterDef<T>[TATableFilterType][];
+};
+export interface IATableFilter<T extends IItem> {
+    String: {
+        type: 'String';
+        defKey: keyof T | '';
+        value: string;
+        predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['String']) => any;
+        placeholder?: string;
+    };
+    Select: {
+        type: 'Select';
+        defKey: keyof T | '';
+        values: (string | number)[];
+        options: (string | number)[];
+        placeholder?: string;
+        OptionRenderer?: (option: string | number) => React.ReactNode;
+        predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Select']) => any;
+    };
+    Date: {
+        type: 'Date';
+        defKey: keyof T;
+        value: Date;
+        minDate?: Date;
+        maxDate?: Date;
+        predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Date']) => any;
+    };
+    DateRange: {
+        type: 'DateRange';
+        defKey: keyof T | '';
+        sDate: Date;
+        eDate: Date;
+        minDate?: Date;
+        maxDate?: Date;
+        predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['DateRange']) => any;
+    };
+}
+export type TATableSomeFilter<T extends IItem> = IATableFilter<T>[TATableFilterType];
+export type TATableFilteration<T extends IItem> = {
+    type: 'And' | 'Or';
+    filters: TATableSomeFilter<T>[];
+};
+export type TATableSortF<T extends IItem> = (a: T, b: T) => number;
+export interface IATableSortation<T extends IItem> {
+    defKey?: keyof T;
+    isAsc?: boolean;
+    sortF?: TATableSortF<T>;
+}
+export interface IATablePagination {
+    page: number;
+    pageSize: number;
+    pageRange: number;
+}
+export interface IATableState<T extends IItem> {
+    entireItems?: T[];
+    filteration: TATableFilteration<T>;
+    pagination: IATablePagination;
+    sortation: IATableSortation<T>;
+}
+export interface IATableProps<T extends IItem> {
+    defs: TATableDefs<T>;
+    defaultDef?: IATableDef<T>;
+    rProps?: TCBAble<IATableTRProps<T>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>>;
+    useSelect?: TUseValues<T[]>;
+    isSelectMulti?: boolean;
+    selectDisabled?: (item: T) => string | boolean | undefined;
+    useCheck?: TUseValues<T[]>;
+    checkDisabled?: (item: T) => string | boolean | undefined;
+    isLoading?: boolean;
+    isDisabled?: boolean;
+    title?: React.ReactNode;
+    entireItems?: T[];
+    onStateChange?: (params: IATableState<T>) => void;
+    pagedItems?: T[];
+    totalCount?: number;
+    filterationDefs?: TATableFilterationDefs<T>;
+    useFilteration?: TUseValues<TATableFilteration<T>>;
+    toggleFilterationDefs?: TATableFilterationDefs<T>;
+    useToggleFilteration?: TUseValues<TATableFilteration<T>>;
+    usePagination?: TUseValues<IATablePagination>;
+    useSortation?: TUseValues<IATableSortation<T>>;
+    TopRightAddon?: React.ReactNode;
+    resources?: Partial<typeof Resources.ATable>;
+}
+export declare const ATable: <T extends IItem>({ defs: extDefs, defaultDef: extDefaultDef, rProps, useSelect, isSelectMulti, selectDisabled, useCheck, checkDisabled, isLoading, isDisabled, title, entireItems, onStateChange, pagedItems: extPagedItems, totalCount: extTotalCount, filterationDefs, useFilteration, toggleFilterationDefs, useToggleFilteration, usePagination, useSortation, TopRightAddon, resources: extResources, }: IATableProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/AModule/AComponents/ATable/ATableBody.d.ts

@@ -0,0 +1,20 @@
+import { TCBAble } from '../../AUtils/cbF';
+import { IItem } from '../../AUtils/objF';
+import { IATablePagination, IATableSortation, IATableTRProps, TATableDefs, TATableFilteration } from './ATable';
+import { TUseValues } from '../../AHooks/useValues';
+import React from 'react';
+interface IATableBodyProps<T extends IItem> {
+    defs: TATableDefs<T>;
+    rProps?: TCBAble<IATableTRProps<T>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>>;
+    useSelect?: TUseValues<T[]>;
+    isTableDisabled?: boolean;
+    isSelectMulti?: boolean;
+    selectDisabled?: (item: T) => string | boolean | undefined;
+    appliedFilteration: TATableFilteration<T>;
+    useSortation: TUseValues<IATableSortation<T>>;
+    pagination: IATablePagination;
+    pagedItems: T[];
+}
+export declare const ATableBody: <T extends IItem>({ defs, rProps, useSelect, isTableDisabled, isSelectMulti, selectDisabled, appliedFilteration, useSortation, pagedItems, }: IATableBodyProps<T>) => import("react/jsx-runtime").JSX.Element;
+export declare const randomHexColor: (alpha?: number) => string;
+export {};

package/dist/AModule/AComponents/ATable/ATableFilter.d.ts

@@ -0,0 +1,12 @@
+import { IItem } from '../../AUtils/objF';
+import { TATableFilteration } from './ATable';
+import { IATableFilterF } from './ATableHeader';
+import { TUseValues } from '../../AHooks/useValues';
+import { Resources } from '../AResource/AResource';
+interface IATableFilterProps<T extends IItem> {
+    useFilteration: TUseValues<TATableFilteration<T>>;
+    filterF: IATableFilterF;
+    resources: typeof Resources.ATable;
+}
+export declare const ATableFilter: <T extends IItem>({ useFilteration, filterF, resources }: IATableFilterProps<T>) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/AModule/AComponents/ATable/ATableFooter.d.ts

@@ -0,0 +1,14 @@
+import { IATablePagination } from './ATable';
+export interface IATableFooterProps {
+    pages: number[];
+    rangedPages: number[];
+    pageF: {
+        move: (page: number) => void;
+        movePrev: () => void;
+        moveNext: () => void;
+        moveFirst: () => void;
+        moveLast: () => void;
+    };
+    pagination: IATablePagination;
+}
+export declare const ATableFooter: ({ pages, rangedPages, pageF, pagination }: IATableFooterProps) => import("react/jsx-runtime").JSX.Element;

package/dist/AModule/AComponents/ATable/ATableHeader.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+import { IItem } from '../../AUtils/objF';
+import { TUseValues } from '../../AHooks/useValues';
+import { TATableFilteration } from './ATable';
+import { Resources } from '../AResource/AResource';
+export interface IATableFilterF {
+    apply: () => void;
+    toggle: () => void;
+    clear: () => void;
+}
+export interface IATableHeaderProps<T extends IItem> {
+    title?: React.ReactNode;
+    totalCount: number;
+    useCheck?: TUseValues<T[]>;
+    useFilteration: TUseValues<TATableFilteration<T>>;
+    filterF: IATableFilterF;
+    TopLeftAddon?: React.ReactNode;
+    TopRightAddon?: React.ReactNode;
+    resources: typeof Resources.ATable;
+}
+export declare const ATableHeader: <T extends IItem>({ title, totalCount, useCheck, useFilteration, filterF, TopLeftAddon, TopRightAddon, resources, }: IATableHeaderProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/AModule/AComponents/ATest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ATest
+ *
+ * Warning : this file is only for development and testing purposes.
+ * the code uses eval function to test callback functions.
+ * NEVER let this code exist in production environment. *
+ *
+ */
+export declare const ATest: () => import("react/jsx-runtime").JSX.Element;

package/dist/AModule/AComponents/AText/AText.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface IATextProps {
+    text?: string;
+    styled?: boolean | string;
+    style?: 'bold' | React.CSSProperties;
+}
+export declare const AText: ({ text, styled, style }: IATextProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/AModule/AComponents/ATextArea/ATextArea.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { IAWrapProps } from '../AWrap/AWrap';
+import { IABaseProps } from '../ABase/ABase';
+import { TUseValues } from '../../AHooks/useValues';
+export type TTextAreaType = 'Primary' | 'Secondary' | 'Error';
+export interface IATextAreaProps extends IABaseProps, IAWrapProps {
+    onEnterPress?: (value: string) => void;
+    type?: TTextAreaType;
+    textAreaRef?: React.RefObject<HTMLTextAreaElement>;
+    useValue?: TUseValues<string>;
+    rows?: number;
+    readonly?: boolean;
+    onBlur?: (e: React.FocusEvent<HTMLTextAreaElement>) => void;
+    onChange?: (e: React.ChangeEvent<HTMLTextAreaElement>) => void;
+    placeholder?: string;
+    maxLength?: number;
+    tabIndex?: number;
+    autoFocus?: boolean;
+    textAreaProps?: React.TextareaHTMLAttributes<HTMLTextAreaElement>;
+}
+export declare const ATextArea: ({ onEnterPress, type, textAreaRef, useValue, rows, readonly, placeholder, maxLength, tabIndex, autoFocus, textAreaProps, wrapProps, helperText, label, wrapType, ...abaseProps }: IATextAreaProps) => React.ReactNode;

package/dist/AModule/AComponents/ATheme/AStyles.d.ts

@@ -0,0 +1,22 @@
+import { TIdx } from '../ATypes/ATypes';
+/**
+ * AStyles.tsx
+ * style maps for AModule
+ *
+ * Notice 1 : Naming Convention of Color Variables
+ * - Component Styles are named by the following rule
+ * - '--ComponentName-[...ClassName]-Property'
+ */
+export interface IStyle {
+    [key: TIdx]: string;
+}
+export interface ICustomeStyle extends IStyle {
+    '--style': string;
+}
+export declare const Styles: IStyle[];
+export declare const componentStyles: IStyle;
+export declare const AStyles: {
+    Default: IStyle;
+    Styles: IStyle[];
+    OverrideStyle: IStyle;
+};

package/dist/AModule/AComponents/ATheme/ATheme.d.ts

@@ -0,0 +1,8 @@
+import { componentStyles } from './AStyles';
+import './ATheme.module.scss';
+export declare const ATheme: {
+    Init: (mode?: 'Light' | 'Dark') => void;
+    GetColorMode: () => string;
+    SetColorMode: (newMode: 'Light' | 'Dark') => void;
+    OverrideStyle: (key: keyof typeof componentStyles, value: string) => void;
+};

package/dist/AModule/AComponents/ATooltip/ATooltip.d.ts

@@ -0,0 +1,9 @@
+import { RefObject } from 'react';
+interface IATooltipProps {
+    tooltip: React.ReactNode;
+    targetRef: RefObject<HTMLElement>;
+    delay?: number;
+    distance?: number;
+}
+export declare const ATooltip: ({ tooltip, targetRef, delay, distance }: IATooltipProps) => import("react").ReactPortal | null;
+export {};

package/dist/AModule/AComponents/ATree/ATree.d.ts

@@ -0,0 +1,54 @@
+/**
+ * ATree
+ * Description :
+ * - select and check is not different, check is just appeared when showCheckbox is true.
+ *
+ * Notice 1 : useSelect is considered as T[], so you should pass T[] to useSelect even if isSelectMulti is false.
+ * Todo 1 : drag between different parents
+ * Todo 2 : maybe adding defs for tree is necessary
+ */
+import React from 'react';
+import { TIcons } from '../AIcon/AIcon';
+import { TUseValues } from '../../AHooks/useValues';
+import { IABaseProps } from '../ABase/ABase';
+import { TActionRef } from '../ATypes/ATypes';
+import { IItem } from '../../AUtils/objF';
+import { IATreeItemProps } from './ATreeItem';
+import { Resources } from '../AResource/AResource';
+export interface IATreeSearchResult<T> {
+    keyword: string;
+    items: T[];
+    item?: T;
+}
+export interface IATreeItem<T> extends IItem {
+    children?: T[];
+}
+export interface IATreeAction {
+    expandAll: () => void;
+    collapseAll: () => void;
+}
+export interface IATreeProps<T extends IATreeItem<T>> extends IABaseProps {
+    ItemRenderer?: (props: IATreeItemProps<T>) => React.ReactNode;
+    useItems?: TUseValues<T[]>;
+    useExpand?: TUseValues<T[]>;
+    useSelect?: TUseValues<T[]>;
+    selectDisabled?: (item: T) => boolean | string | undefined;
+    useSearch?: TUseValues<IATreeSearchResult<T> | undefined>;
+    showCheckbox?: boolean;
+    icons?: {
+        noChild?: TIcons;
+        collapsed?: TIcons;
+        expanded?: TIcons;
+    };
+    iconWidth?: number;
+    isSelectMulti?: boolean;
+    noSearch?: boolean;
+    enableDrag?: boolean;
+    syncSearchSelect?: boolean;
+    searchPredicate?: (inputValue: string, item: IATreeItem<T>) => any;
+    actionRef?: TActionRef<IATreeAction>;
+    HeaderRightAddon?: React.ReactNode;
+    RightStickyRenderer?: (props: IATreeItemProps<T>) => React.ReactNode;
+    resources?: Partial<typeof Resources.ATree>;
+}
+export declare const ATree: <T extends IATreeItem<T>>({ selectDisabled, ItemRenderer, useItems, useExpand, useSelect, useSearch, showCheckbox, iconWidth, icons, isSelectMulti, noSearch, enableDrag, syncSearchSelect, actionRef, HeaderRightAddon, RightStickyRenderer, resources: extResources, searchPredicate, isDisabled, ...abaseProps }: IATreeProps<T>) => React.ReactNode;

package/dist/AModule/AComponents/ATree/ATreeItem.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { TIcons } from '../AIcon/AIcon';
+import { TUseValues } from '../../AHooks/useValues';
+import { IATreeItem, IATreeSearchResult } from './ATree';
+import { Resources } from '../AResource/AResource';
+export interface IATreeItemProps<T> {
+    item: T;
+    selectDisabled?: (item: T) => boolean | string | undefined;
+    isParentDisabled?: boolean;
+    indents: EIndentState[];
+    ItemRenderer: (props: IATreeItemProps<T>) => React.ReactNode;
+    useExpand: TUseValues<T[]>;
+    useSelect: TUseValues<T[]>;
+    useSearch: TUseValues<IATreeSearchResult<T> | undefined>;
+    onDragStart?: (item: T) => void;
+    onDragOver?: (e: React.DragEvent<HTMLElement>, item: T) => void;
+    onDragEnd?: (e: React.DragEvent<HTMLElement>, item: T) => void;
+    showCheckbox?: boolean;
+    icons?: {
+        noChild?: TIcons;
+        collapsed?: TIcons;
+        expanded?: TIcons;
+    };
+    iconWidth: number;
+    isSelectMulti: boolean;
+    enableDrag: boolean;
+    isParentCheckHovered: boolean;
+    RightStickyRenderer?: (props: IATreeItemProps<T>) => React.ReactNode;
+    resources: typeof Resources.ATree;
+}
+declare enum EIndentState {
+    Collapsed = "Collapsed",
+    Expanded = "Expanded",
+    IsLast = "IsLast"
+}
+export declare const ATreeItem: <T extends IATreeItem<T>>({ item, selectDisabled, isParentDisabled, indents, ItemRenderer, useExpand, useSelect, useSearch, onDragStart, onDragOver, onDragEnd, showCheckbox, icons, iconWidth, isSelectMulti, enableDrag, isParentCheckHovered, RightStickyRenderer, resources, }: IATreeItemProps<T>) => React.ReactNode;
+export {};

package/dist/AModule/AComponents/ATree/ATreeSearch.d.ts

@@ -0,0 +1,11 @@
+import { IATreeItem, IATreeSearchResult } from './ATree';
+interface IATreeSearchProps<T extends IATreeItem<T>> {
+    searchResult: IATreeSearchResult<T> | undefined;
+    initSearch: (inputValue: string) => void;
+    searchUp: () => void;
+    searchDown: () => void;
+    isDisabled?: boolean;
+    isLoading?: boolean;
+}
+export declare const ATreeSearch: <T extends IATreeItem<T>>({ searchResult, initSearch, searchUp, searchDown, isDisabled, isLoading, }: IATreeSearchProps<T>) => React.ReactNode;
+export {};

package/dist/AModule/AComponents/ATypes/ATypes.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="react" />
+export type TPromisable<T> = T | Promise<T>;
+/**
+ * getDir12Style
+ * Notice 1 : N, S, E, W are available when self is not falsy
+ */
+export declare enum EDir4 {
+    N = "North",
+    S = "South",
+    E = "East",
+    W = "West"
+}
+export declare enum EDir12 {
+    N = "North",
+    NW = "NorthWest",
+    NE = "NorthEast",
+    S = "South",
+    SW = "SouthWest",
+    SE = "SouthEast",
+    E = "East",
+    EN = "EastNorth",
+    ES = "EastSouth",
+    W = "West",
+    WN = "WestNorth",
+    WS = "WestSouth"
+}
+export declare function setDir12Style(anchorRef: React.RefObject<HTMLElement>, selfRef: React.RefObject<HTMLElement>, dir: EDir12): void;
+export type TActionRef<T> = React.MutableRefObject<T | null | undefined>;
+/**
+ * IFable (IFunctionable)
+ * it has a returns R, and it can be a function that takes P and returns R
+ */
+export type TIdx = number | string;

package/dist/AModule/AComponents/AWrap/AWrap.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export interface IAWrapProps {
+    wrapProps?: React.HTMLAttributes<HTMLDivElement>;
+    helperText?: React.ReactNode | React.ReactNode[];
+    wrapType?: 'Default' | 'Error';
+    label?: React.ReactNode;
+    vspace?: number;
+    hspace?: number;
+    children?: React.ReactNode;
+}
+export declare const AWrap: ({ wrapProps, helperText, wrapType, label, children }: IAWrapProps) => React.ReactNode;

package/dist/AModule/AHooks/useValues.d.ts

@@ -0,0 +1,12 @@
+/**
+ * useValues
+ * Notice 1 : useValues uses conditional hook. YOU SHOULD NEVER change the conditions. or it will boom
+ *
+ * 1. use === undefined 이면 useState<T>(defaultValue) (internal value, internal setter)
+ * 2. use === [T] 이면 useState<T>(use[0])             (defaultValue)
+ * 3. use === [T, undefined] 이면 use                  (fixed value)
+ * 4. use === [T, (newState: T) => void] 이면 use      (external value, external setter)
+ *
+ */
+export type TUseValues<T> = [T] | [T, ((newState: T) => void) | undefined];
+export declare function useValues<T>(use: TUseValues<T> | undefined, defaultValue: T): [T, ((newState: T) => void) | undefined];

package/dist/AModule/ANetwork/APIContext.d.ts

@@ -0,0 +1,39 @@
+export declare const ApiContext: {
+    Init: () => void;
+    Create: <PO, RO>(context: IApiContextParam) => {
+        Call: (params?: {
+            po?: PO | undefined;
+            onStream?: IOnStream<RO> | undefined;
+            onStreamEnd?: IOnStream<RO> | undefined;
+            noDefaultHandle?: boolean | number[] | undefined;
+        } | undefined) => Promise<{
+            errorCode: number;
+            message: string;
+            data?: RO | undefined;
+        }>;
+    };
+    FetchBaseUrl: () => string;
+    useDefaultHandler: (handler: (ro: IApiCallResult<any>, noDefaultHandle: number[] | boolean) => void) => void;
+};
+export interface IApiContextParam {
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    stream?: boolean;
+    paramType?: 'query' | 'body' | 'form';
+    timeout?: number;
+}
+export interface IApiContext<PO, RO> {
+    Call: (po?: PO) => Promise<IApiCallResult<RO>>;
+}
+export interface IApiCallResult<RO> {
+    errorCode: number;
+    message: string;
+    data?: RO;
+}
+export interface IApiCallError {
+    err_code: number;
+    err_msg: string;
+}
+export interface IOnStream<RO> {
+    (ro: RO): void;
+}

package/dist/AModule/AUtils/bound.d.ts

@@ -0,0 +1 @@
+export declare function bound(targetValue: number, minValue?: number, maxValue?: number): number;

package/dist/AModule/AUtils/cbF.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Renderer is a callback function for some items.
+ * content is a ReactNode | Renderer fomr some items.
+ *
+ * Notice 1 : R cannot be a function. ICBAble is available when R is not a function.
+ *
+ * Todo 1 : F as Function is used for typecheck-bypassing. it might make some errors
+ */
+type TExcludeFunction<R> = R extends (...args: any[]) => any ? never : R;
+export type TCB<P, R> = (props: P) => R;
+export type TCBAble<P, R> = TExcludeFunction<R> | TCB<P, TExcludeFunction<R>>;
+declare function getContent<P, R>(F: TCBAble<P, R>, props: P): TExcludeFunction<R>;
+export declare const cbF: {
+    getContent: typeof getContent;
+};
+export {};

package/dist/AModule/AUtils/classF.d.ts

@@ -0,0 +1,10 @@
+type CSSModuleClasses = {
+    readonly [key: string]: string;
+};
+declare function clsx(...args: any[]): string;
+declare function sclsx(styles: CSSModuleClasses, ...args: any[]): string;
+export declare const classF: {
+    clsx: typeof clsx;
+    sclsx: typeof sclsx;
+};
+export {};

package/dist/AModule/AUtils/dateF.d.ts

@@ -0,0 +1,35 @@
+/**
+ * for form YYYY-MM-DD
+ */
+declare function toString(date: Date): string;
+declare function toDate(str: string): Date | null;
+declare function makeSDate(date: Date): Date;
+declare function makeEDate(date: Date): Date;
+declare function eq(d1: Date, d2: Date): boolean;
+declare function g(d1: Date, d2: Date): boolean;
+declare function ge(d1: Date, d2: Date): boolean;
+declare function l(d1: Date, d2: Date): boolean;
+declare function le(d1: Date, d2: Date): boolean;
+declare function b(s: Date, d: Date, e: Date): boolean;
+declare function be(s: Date, d: Date, e: Date): boolean;
+export declare const dateF: {
+    toString: typeof toString;
+    toDate: typeof toDate;
+    makeSDate: typeof makeSDate;
+    makeEDate: typeof makeEDate;
+    '===': typeof eq;
+    '>': typeof g;
+    '>=': typeof ge;
+    '<': typeof l;
+    '<=': typeof le;
+    's<d<e|e<d<s': typeof b;
+    's<=d<=e|e<=d<=s': typeof be;
+    eq: typeof eq;
+    g: typeof g;
+    ge: typeof ge;
+    l: typeof l;
+    le: typeof le;
+    b: typeof b;
+    be: typeof be;
+};
+export {};

package/dist/AModule/AUtils/objF.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { TIdx } from '../AComponents/ATypes/ATypes';
+export interface IObject {
+    [key: TIdx]: any;
+}
+export interface IItem extends IObject {
+    idx?: TIdx;
+}
+declare function equal<T extends IItem>(a: T, b: T): boolean;
+export declare const objF: {
+    equal: typeof equal;
+    parse: <T>(value: string) => T | undefined;
+    stringify: (value: any, indent?: number | string) => string;
+    keys: <T_1 extends IObject>(obj: T_1) => (keyof T_1)[];
+    values: <T_2 extends IObject>(obj: T_2) => T_2[keyof T_2][];
+    hasKey: <T_3 extends IObject>(obj: T_3, key: string | number | symbol) => key is keyof T_3;
+    map: <T_4 extends IObject, U>(obj: T_4, fn: (keyValue: [keyof T_4, T_4[keyof T_4]], idx: number) => U) => U[];
+    some: <T_5 extends IObject>(obj: T_5, fn: (key: keyof T_5, value: T_5[keyof T_5]) => any) => boolean;
+    find: <T_6 extends IObject>(obj: T_6, fn: (key: keyof T_6, value: T_6[keyof T_6]) => any) => [string, any] | undefined;
+    isReactNode: (value: any) => value is React.ReactNode;
+};
+export {};

package/dist/AModule/AUtils/strF.d.ts

@@ -0,0 +1,3 @@
+export declare const strF: {
+    SecondToTime: (seconds: number) => string;
+};

package/dist/AModule/AUtils/tableF.d.ts

@@ -0,0 +1,17 @@
+import { IATableFilter, IATableSortation, TATableDefs, TATableFilterType, TATableFilteration } from '../AComponents/ATable/ATable';
+import { IItem } from './objF';
+type TDefaultPredicate = {
+    [key in TATableFilterType]: IATableFilter<any>[key]['predicate'];
+};
+export declare const defaultPredicate: TDefaultPredicate;
+export declare const tableF: {
+    applyFilteration: <T extends IItem>(items: T[], defs: TATableDefs<T>, filteration: TATableFilteration<T>) => T[];
+    applySortation: <T_1 extends IItem>(items: T_1[], defs: TATableDefs<T_1>, sortation: IATableSortation<T_1>) => T_1[];
+    applyPagination: <T_2 extends IItem>(items: T_2[], page: number, pageSize: number) => T_2[];
+    getPages: (totalCount: number, pageSize: number) => number[];
+    getRangedPages: (page: number, totalCount: number, pageSize: number, pageRange: number) => {
+        pages: number[];
+        rangedPages: number[];
+    };
+};
+export {};

package/dist/AModule/AUtils/treeF.d.ts

@@ -0,0 +1,22 @@
+import { TIdx } from '../AComponents/ATypes/ATypes';
+import { IATreeItem } from '../AComponents/ATree/ATree';
+import { IItem } from './objF';
+declare function equal<T extends IItem>(a: T, b: T): boolean;
+declare function find<T extends IATreeItem<T>>(items: T[] | T, predicate: (item: T, idx?: TIdx) => any): T | undefined;
+declare function forEach<T extends IATreeItem<T>>(items: T[] | T, callback: (item: T, idx?: TIdx) => void): void;
+declare function map<T extends IATreeItem<T>, R>(items: T[] | T, callback: (item: T, idx?: TIdx) => R): R[];
+declare function every<T extends IATreeItem<T>>(items: T[] | T, predicate: (item: T, idx?: TIdx) => boolean): boolean;
+declare function filter<T extends IATreeItem<T>>(items: T[] | T, predicate: (item: T, idx?: TIdx) => boolean): T[];
+declare function length<T extends IATreeItem<T>>(items: T[] | T): number;
+declare function replace<T extends IATreeItem<T>>(items: T[] | T, srcItem: T, dstItem: T): T[] | null;
+export declare const treeF: {
+    find: typeof find;
+    forEach: typeof forEach;
+    map: typeof map;
+    every: typeof every;
+    filter: typeof filter;
+    equal: typeof equal;
+    length: typeof length;
+    replace: typeof replace;
+};
+export {};