ados-rcm 1.0.8 → 1.0.10

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

@@ -1,11 +1,11 @@
-import { TCBAble } from '../../AUtils/cbF';
+import { TCanCallback } 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>>;
+    rProps?: TCanCallback<IATableTRProps<T>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>>;
     useSelect?: TUseValues<T[]>;
     isTableDisabled?: boolean;
     isSelectMulti?: boolean;

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

@@ -1,8 +1,32 @@
 import React from 'react';
 interface IATextProps {
+    /**
+     * text? : string
+     * <br/>Description : text of AText
+     */
     text?: string;
+    /**
+     * styled? : boolean | string
+     * <br/>Description : styled of AText. if true, all text is styled. if string, the matching string on text will be styled.
+     */
     styled?: boolean | string;
+    /**
+     * style? : 'bold' | React.CSSProperties
+     * <br/>Description : style of AText. if 'bold', text will be bold. if React.CSSProperties, text will be styled with the style.
+     */
     style?: 'bold' | React.CSSProperties;
 }
+/**
+ * AComponent : AText
+ * <br/>Description : AText is a text component that can be styled.
+ * <br/>Basic Usage :
+ * <br/>(1)<AText text="This is text"/>
+ *
+ * <br/>(2)<AText text="This is text" styled/>
+ *
+ * <br/>(3)<AText text="This is text" styled="is" style='bold'/>
+ *
+ * <br/>(4)<AText text="This is text" styled="text" style={{color: 'red'}}/>
+ */
 export declare const AText: ({ text, styled, style }: IATextProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -4,18 +4,94 @@ 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
+     * <br/>Description : onEnterPress of ATextArea
+     * <br/>Basic Usage :
+     * <br/>(1)<AInput onEnterPress={value => console.log(value)}/>
+     */
     onEnterPress?: (value: string) => void;
+    /**
+     * type? : TTextAreaType = 'Primary'
+     * <br/>Description : type of ATextArea
+     * <br/>Basic Usage :
+     * <br/>(1)<AInput type="Secondary"/>
+     */
     type?: TTextAreaType;
+    /**
+     * textAreaRef? : React.RefObject<HTMLTextAreaElement>
+     * <br/>Description : textAreaRef of ATextArea
+     * <br/>Basic Usage :
+     * <br/>(1)const textAreaRef = useRef<HTMLTextAreaElement>(null);
+     * <AInput textAreaRef={textAreaRef}/>
+     */
     textAreaRef?: React.RefObject<HTMLTextAreaElement>;
+    /**
+     * useValue? : TUseValues<string>
+     * <br/>Description : useValue of ATextArea
+     * <br/>Basic Usage :
+     * <br/>(1)const [value, setValue] = useState<string>('');
+     * <AInput useValue={[value, setValue]}/>
+     */
     useValue?: TUseValues<string>;
+    /**
+     * rows? : number
+     * <br/>Description : rows of ATextArea
+     * <br/>Basic Usage :
+     * <br/>(1)<ATextArea rows={5}/>
+     */
     rows?: number;
+    /**
+     * readonly? : boolean
+     * <br/>Description : decides whether the input is readonly or not
+     * <br/>Basic Usage :
+     * <br/>(1)<ATextArea readonly/>
+     */
     readonly?: boolean;
-    onBlur?: (e: React.FocusEvent<HTMLTextAreaElement>) => void;
+    /**
+     * onChange? : (e: React.ChangeEvent<HTMLTextAreaElement>) => void
+     * <br/>Description : onChange of ATextArea
+     */
     onChange?: (e: React.ChangeEvent<HTMLTextAreaElement>) => void;
+    /**
+     * placeholder? : string
+     * <br/>Description : placeholder of ATextArea
+     * <br/>Basic Usage :
+     * <br/>(1)<ATextArea placeholder="Placeholder"/>
+     */
     placeholder?: string;
+    /**
+     * maxLength? : number
+     * <br/>Description : maxLength of ATextArea
+     * <br/>Basic Usage :
+     * <br/>(1)<ATextArea maxLength={10}/>
+     */
     maxLength?: number;
+    /**
+     * tabIndex? : number
+     * <br/>Description : tabIndex of ATextArea
+     * <br/>Basic Usage :
+     * <br/>(1)<ATextArea tabIndex={1}/>
+     */
     tabIndex?: number;
+    /**
+     * autoFocus? : boolean
+     * <br/>Description : decides whether the input is focused or not
+     * <br/>Basic Usage :
+     * <br/>(1)<ATextArea autoFocus/>
+     */
     autoFocus?: boolean;
+    /**
+     * textAreaProps? : React.TextareaHTMLAttributes<HTMLTextAreaElement>
+     * <br/>Description : textAreaProps of ATextArea
+     */
     textAreaProps?: React.TextareaHTMLAttributes<HTMLTextAreaElement>;
 }
+/**
+ * AComponent : ATextArea
+ * <br/>Description : ATextArea is a textarea component. it has AWrap and ABase inside, so be careful with the styles. I recommend checking out the element hierarchy first.
+ * <br/>Basic Usage :
+ * <br/>(1)const [value, setValue] = useState<string>('');
+ * return <ATextArea useValue={[value, setValue]}/>
+ */
 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/ATooltip/ATooltip.d.ts

@@ -1,9 +1,36 @@
 import { RefObject } from 'react';
 interface IATooltipProps {
+    /**
+     * tooltip : React.ReactNode
+     * <br/>Description : tooltip of ATooltip
+     */
     tooltip: React.ReactNode;
+    /**
+     * targetRef : React.RefObject<HTMLElement>
+     * <br/>Description : targetRef of ATooltip
+     */
     targetRef: RefObject<HTMLElement>;
-    delay?: number;
-    distance?: number;
+    /**
+     * delay? : number = 0
+     * <br/>Description : delay of ATooltip
+     */
+    delay: number;
+    /**
+     * distance? : number = 10
+     * <br/>Description : distance of ATooltip
+     */
+    distance: number;
 }
+/**
+ * AComponent : ATooltip
+ * <br/>Description : ATooltip is a tooltip component that can be attached to a target element.
+ * <br/>Basic Usage :
+ * <br/>(1)const targetRef = useRef<HTMLDivElement>(null);
+ * return <>
+ *   <div ref={targetRef}>Hover me</div>
+ *   <ATooltip tooltip="This is tooltip" targetRef={targetRef}/>
+ * </>
+ *
+ */
 export declare const ATooltip: ({ tooltip, targetRef, delay, distance }: IATooltipProps) => import("react").ReactPortal | null;
 export {};

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

@@ -1,6 +1,6 @@
 /**
  * ATree
- * Description :
+ * <br/>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.
@@ -8,47 +8,165 @@
  * Todo 2 : maybe adding defs for tree is necessary
  */
 import React from 'react';
-import { TIcons } from '../AIcon/AIcon';
 import { TUseValues } from '../../AHooks/useValues';
+import { IItem } from '../../AUtils/objF';
 import { IABaseProps } from '../ABase/ABase';
+import { TIcons } from '../AIcon/AIcon';
+import { Resources } from '../AResource/AResource';
 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
+     * <br/>Description : keyword of search result
+     */
     keyword: string;
+    /**
+     * items : T[]
+     * <br/>Description : items of search result
+     */
     items: T[];
+    /**
+     * item? : T
+     * <br/>Description : item of search result
+     */
     item?: T;
 }
 export interface IATreeItem<T> extends IItem {
+    /**
+     * children? : T[]
+     * <br/>Description : children of IATreeItem. tree will be rendered recursively.
+     */
     children?: T[];
 }
 export interface IATreeAction {
+    /**
+     * expandAll : () => void
+     * <br/>Description : expand all items
+     */
     expandAll: () => void;
+    /**
+     * collapseAll : () => void
+     * <br/>Description : collapse all items
+     */
     collapseAll: () => void;
 }
 export interface IATreeProps<T extends IATreeItem<T>> extends IABaseProps {
+    /**
+     * ItemRenderer? : (props: IATreeItemProps<T>) => React.ReactNode
+     * <br/>Description : ItemRenderer of ATree
+     */
     ItemRenderer?: (props: IATreeItemProps<T>) => React.ReactNode;
+    /**
+     * useItems? : TUseValues<T[]>
+     * <br/>Description : useItems of ATree. items will be changed if dragging is used
+     */
     useItems?: TUseValues<T[]>;
+    /**
+     * useExpand? : TUseValues<T[]>
+     * <br/>Description : useExpand of ATree
+     */
     useExpand?: TUseValues<T[]>;
+    /**
+     * useSelect? : TUseValues<T[]>
+     * <br/>Description : useSelect of ATree
+     */
     useSelect?: TUseValues<T[]>;
+    /**
+     * selectDisabled? : (item: T) => boolean | string | undefined
+     * <br/>Description : selectDisabled of ATree. if string is returned, it will be used as tooltip.
+     */
     selectDisabled?: (item: T) => boolean | string | undefined;
+    /**
+     * useSearch? : TUseValues<IATreeSearchResult<T> | undefined>
+     * <br/>Description : useSearch of ATree
+     */
     useSearch?: TUseValues<IATreeSearchResult<T> | undefined>;
+    /**
+     * showCheckbox? : boolean
+     * <br/>Description : showCheckbox of ATree
+     */
     showCheckbox?: boolean;
+    /**
+     * icons? : { noChild?: TIcons; collapsed?: TIcons; expanded?: TIcons }
+     * <br/>Description : icons of ATree
+     */
     icons?: {
         noChild?: TIcons;
         collapsed?: TIcons;
         expanded?: TIcons;
     };
+    /**
+     * iconWidth? : number
+     * <br/>Description : iconWidth of ATree
+     */
     iconWidth?: number;
+    /**
+     * isSelectMulti? : boolean
+     * <br/>Description : isSelectMulti of ATree
+     */
     isSelectMulti?: boolean;
+    /**
+     * noSearch? : boolean
+     * <br/>Description : noSearch of ATree. if true, search will not be rendered.
+     */
     noSearch?: boolean;
+    /**
+     * enableDrag? : boolean
+     * <br/>Description : enableDrag of ATree
+     */
     enableDrag?: boolean;
+    /**
+     * syncSearchSelect? : boolean
+     * <br/>Description : syncSearchSelect of ATree. if true, selectedItems will be synced with searchResult.
+     */
     syncSearchSelect?: boolean;
+    /**
+     * searchPredicate? : (inputValue: string, item: IATreeItem<T>) => any
+     * <br/>Description : searchPredicate of ATree.
+     */
     searchPredicate?: (inputValue: string, item: IATreeItem<T>) => any;
+    /**
+     * actionRef? : TActionRef<IATreeAction>
+     * <br/>Description : actionRef of ATree
+     */
     actionRef?: TActionRef<IATreeAction>;
+    /**
+     * HeaderRightAddon? : React.ReactNode
+     * <br/>Description : HeaderRightAddon of ATree
+     */
     HeaderRightAddon?: React.ReactNode;
+    /**
+     * RightStickyRenderer? : (props: IATreeItemProps<T>) => React.ReactNode
+     * <br/>Description : RightStickyRenderer of ATree
+     */
     RightStickyRenderer?: (props: IATreeItemProps<T>) => React.ReactNode;
+    /**
+     * resources? : Partial<typeof Resources.ATree>
+     * <br/>Description : resources of ATree
+     */
     resources?: Partial<typeof Resources.ATree>;
 }
+/**
+ * AComponent : ATree
+ * <br/>Description : ATree component. tree will be rendered recursively.
+ * select and check are not different, check is just appeared when showCheckbox is true.
+ * select, check, expand, drag-to-move, search are available.
+ * <br/>Basic Usage :
+ * <br/>(1)const items = [{name: 'Item1', children: [{name: 'Item1-1'}]}];
+ * return <ATree useItems={[items, setItems]}/>
+ *
+ * <br/>(2)const items = [{name: 'Item1', children: [{name: 'Item1-1'}]}, {name: 'Item2'}, {name: 'Item3'}];
+ * const [selected, setSelected] = useState<typeof items[0]>(items[0]);
+ * return <ATree useItems={[items, setItems]} useSelect={[selected, setSelected]}/>
+ *
+ * <br/>(3)const items = [{name: 'Item1', children: [{name: 'Item1-1'}]}, {name: 'Item2'}, {name: 'Item3'}];
+ * const [expanded, setExpanded] = useState<typeof items[0]>(items[0]);
+ * return <ATree useItems={[items, setItems]} useExpand={[expanded, setExpanded]}/>
+ *
+ * <br/>(4)const items = [{name: 'Item1', children: [{name: 'Item1-1'}]}, {name: 'Item2'}, {name: 'Item3'}];
+ * const [searchResult, setSearchResult] = useState<IATreeSearchResult<typeof items[0]> | undefined>(undefined);
+ * return <ATree useItems={[items, setItems]} useSearch={[searchResult, setSearchResult]}/>
+ *
+ */
 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/ATypes/ATypes.d.ts

@@ -26,8 +26,14 @@ export declare enum EDir12 {
 }
 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;
+export interface IAEvent {
+    preventDefault: boolean;
+}
+export interface IAEventCallers {
+    preventDefault: () => void;
+}
+export declare function createEvent(): {
+    event: IAEvent;
+    e: IAEventCallers;
+};

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

@@ -1,11 +1,37 @@
 import React from 'react';
 export interface IAWrapProps {
+    /**
+     * wrapProps? : React.HTMLAttributes<HTMLDivElement>
+     * <br/>Description : wrapProps of AWrap
+     */
     wrapProps?: React.HTMLAttributes<HTMLDivElement>;
+    /**
+     * helperText? : React.ReactNode | React.ReactNode[]
+     * <br/>Description : helperText of AWrap
+     */
     helperText?: React.ReactNode | React.ReactNode[];
+    /**
+     * wrapType? : 'Default' | 'Error' = 'Default'
+     * <br/>Description : wrapType of AWrap
+     */
     wrapType?: 'Default' | 'Error';
+    /**
+     * label? : React.ReactNode
+     * <br/>Description : label of AWrap
+     */
     label?: React.ReactNode;
-    vspace?: number;
-    hspace?: number;
+    /**
+     * children? : React.ReactNode
+     * <br/>Description : children of AWrap
+     */
     children?: React.ReactNode;
 }
+/**
+ * AComponent : AWrap
+ * <br/>Description : AWrap is a wrap component that wraps the children with a label and helper text.
+ * <br/>Basic Usage :
+ * <br/>(1)<AWrap label="Label" helperText="Helper Text">
+ *  <AInput/>
+ * </AWrap>
+ */
 export declare const AWrap: ({ wrapProps, helperText, wrapType, label, children }: IAWrapProps) => React.ReactNode;

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

@@ -7,9 +7,9 @@
  * 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 type TCallback<P, R> = (props: P) => R;
+export type TCanCallback<P, R> = TExcludeFunction<R> | TCallback<P, TExcludeFunction<R>>;
+declare function getContent<P, R>(F: TCanCallback<P, R>, props: P): TExcludeFunction<R>;
 export declare const cbF: {
     getContent: typeof getContent;
 };