ados-rcm 1.0.9 → 1.0.12

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

@@ -2,31 +2,46 @@ import React from 'react';
 interface IATextProps {
     /**
      * text? : string
+     *
      * Description : text of AText
      */
     text?: string;
     /**
      * styled? : boolean | string
+     *
      * 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
+     *
      * 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
+ *
  * Description : AText is a text component that can be styled.
+ *
  * Basic Usage :
- * (1) <AText text="This is text"/>
  *
- * (2) <AText text="This is text" styled/>
+ *     if (case 1)
+ *       <AText text="This is text"/>
+ *
+ *     if (case 2)
+ *       <AText text="This is text"
+ *         styled/>
  *
- * (3) <AText text="This is text" styled="is" style='bold'/>
+ *     if (case 3)
+ *       <AText text="This is text"
+ *         styled="is"
+ *         style='bold'/>
  *
- * (4) <AText text="This is text" styled="text" style={{color: 'red'}}/>
+ *     if (case 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

@@ -6,92 +6,87 @@ export type TTextAreaType = 'Primary' | 'Secondary' | 'Error';
 export interface IATextAreaProps extends IABaseProps, IAWrapProps {
     /**
      * onEnterPress? : (value: string) => void
+     *
      * Description : onEnterPress of ATextArea
-     * Basic Usage :
-     * (1) <AInput onEnterPress={value => console.log(value)}/>
      */
     onEnterPress?: (value: string) => void;
     /**
      * type? : TTextAreaType = 'Primary'
+     *
      * Description : type of ATextArea
-     * Basic Usage :
-     * (1) <AInput type="Secondary"/>
      */
     type?: TTextAreaType;
     /**
      * textAreaRef? : React.RefObject<HTMLTextAreaElement>
+     *
      * Description : textAreaRef of ATextArea
-     * Basic Usage :
-     * (1) const textAreaRef = useRef<HTMLTextAreaElement>(null);
-     * <AInput textAreaRef={textAreaRef}/>
      */
     textAreaRef?: React.RefObject<HTMLTextAreaElement>;
     /**
      * useValue? : TUseValues<string>
+     *
      * Description : useValue of ATextArea
-     * Basic Usage :
-     * (1) const [value, setValue] = useState<string>('');
-     * <AInput useValue={[value, setValue]}/>
      */
     useValue?: TUseValues<string>;
     /**
      * rows? : number
+     *
      * Description : rows of ATextArea
-     * Basic Usage :
-     * (1) <ATextArea rows={5}/>
      */
     rows?: number;
     /**
      * readonly? : boolean
+     *
      * Description : decides whether the input is readonly or not
-     * Basic Usage :
-     * (1) <ATextArea readonly/>
      */
     readonly?: boolean;
     /**
      * onChange? : (e: React.ChangeEvent<HTMLTextAreaElement>) => void
+     *
      * Description : onChange of ATextArea
      */
     onChange?: (e: React.ChangeEvent<HTMLTextAreaElement>) => void;
     /**
      * placeholder? : string
+     *
      * Description : placeholder of ATextArea
-     * Basic Usage :
-     * (1) <ATextArea placeholder="Placeholder"/>
      */
     placeholder?: string;
     /**
      * maxLength? : number
+     *
      * Description : maxLength of ATextArea
-     * Basic Usage :
-     * (1) <ATextArea maxLength={10}/>
      */
     maxLength?: number;
     /**
      * tabIndex? : number
+     *
      * Description : tabIndex of ATextArea
-     * Basic Usage :
-     * (1) <ATextArea tabIndex={1}/>
      */
     tabIndex?: number;
     /**
      * autoFocus? : boolean
+     *
      * Description : decides whether the input is focused or not
-     * Basic Usage :
-     * (1) <ATextArea autoFocus/>
      */
     autoFocus?: boolean;
     /**
      * textAreaProps? : React.TextareaHTMLAttributes<HTMLTextAreaElement>
+     *
      * Description : textAreaProps of ATextArea
      */
     textAreaProps?: React.TextareaHTMLAttributes<HTMLTextAreaElement>;
 }
 /**
  * AComponent : ATextArea
+ *
  * 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.
+ *
  * Basic Usage :
- * (1) const [value, setValue] = useState<string>('');
- * return <ATextArea useValue={[value, setValue]}/>
+ *
+ *     const [value, setValue] = useState('');
+ *
+ *     if (case 1)
+ *       <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

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

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

@@ -1,5 +1,6 @@
 /**
  * ATree
+ *
  * Description :
  * - select and check is not different, check is just appeared when showCheckbox is true.
  *
@@ -18,16 +19,19 @@ import { IATreeItemProps } from './ATreeItem';
 export interface IATreeSearchResult<T> {
     /**
      * keyword : string
+     *
      * Description : keyword of search result
      */
     keyword: string;
     /**
      * items : T[]
+     *
      * Description : items of search result
      */
     items: T[];
     /**
      * item? : T
+     *
      * Description : item of search result
      */
     item?: T;
@@ -35,6 +39,7 @@ export interface IATreeSearchResult<T> {
 export interface IATreeItem<T> extends IItem {
     /**
      * children? : T[]
+     *
      * Description : children of IATreeItem. tree will be rendered recursively.
      */
     children?: T[];
@@ -42,11 +47,13 @@ export interface IATreeItem<T> extends IItem {
 export interface IATreeAction {
     /**
      * expandAll : () => void
+     *
      * Description : expand all items
      */
     expandAll: () => void;
     /**
      * collapseAll : () => void
+     *
      * Description : collapse all items
      */
     collapseAll: () => void;
@@ -54,41 +61,49 @@ export interface IATreeAction {
 export interface IATreeProps<T extends IATreeItem<T>> extends IABaseProps {
     /**
      * ItemRenderer? : (props: IATreeItemProps<T>) => React.ReactNode
+     *
      * Description : ItemRenderer of ATree
      */
     ItemRenderer?: (props: IATreeItemProps<T>) => React.ReactNode;
     /**
      * useItems? : TUseValues<T[]>
+     *
      * Description : useItems of ATree. items will be changed if dragging is used
      */
     useItems?: TUseValues<T[]>;
     /**
      * useExpand? : TUseValues<T[]>
+     *
      * Description : useExpand of ATree
      */
     useExpand?: TUseValues<T[]>;
     /**
      * useSelect? : TUseValues<T[]>
+     *
      * Description : useSelect of ATree
      */
     useSelect?: TUseValues<T[]>;
     /**
      * selectDisabled? : (item: T) => boolean | string | undefined
+     *
      * 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>
+     *
      * Description : useSearch of ATree
      */
     useSearch?: TUseValues<IATreeSearchResult<T> | undefined>;
     /**
      * showCheckbox? : boolean
+     *
      * Description : showCheckbox of ATree
      */
     showCheckbox?: boolean;
     /**
      * icons? : { noChild?: TIcons; collapsed?: TIcons; expanded?: TIcons }
+     *
      * Description : icons of ATree
      */
     icons?: {
@@ -98,75 +113,93 @@ export interface IATreeProps<T extends IATreeItem<T>> extends IABaseProps {
     };
     /**
      * iconWidth? : number
+     *
      * Description : iconWidth of ATree
      */
     iconWidth?: number;
     /**
      * isSelectMulti? : boolean
+     *
      * Description : isSelectMulti of ATree
      */
     isSelectMulti?: boolean;
     /**
      * noSearch? : boolean
+     *
      * Description : noSearch of ATree. if true, search will not be rendered.
      */
     noSearch?: boolean;
     /**
      * enableDrag? : boolean
+     *
      * Description : enableDrag of ATree
      */
     enableDrag?: boolean;
     /**
      * syncSearchSelect? : boolean
+     *
      * Description : syncSearchSelect of ATree. if true, selectedItems will be synced with searchResult.
      */
     syncSearchSelect?: boolean;
     /**
      * searchPredicate? : (inputValue: string, item: IATreeItem<T>) => any
+     *
      * Description : searchPredicate of ATree.
      */
     searchPredicate?: (inputValue: string, item: IATreeItem<T>) => any;
     /**
      * actionRef? : TActionRef<IATreeAction>
+     *
      * Description : actionRef of ATree
      */
     actionRef?: TActionRef<IATreeAction>;
     /**
      * HeaderRightAddon? : React.ReactNode
+     *
      * Description : HeaderRightAddon of ATree
      */
     HeaderRightAddon?: React.ReactNode;
     /**
      * RightStickyRenderer? : (props: IATreeItemProps<T>) => React.ReactNode
+     *
      * Description : RightStickyRenderer of ATree
      */
     RightStickyRenderer?: (props: IATreeItemProps<T>) => React.ReactNode;
     /**
      * resources? : Partial<typeof Resources.ATree>
+     *
      * Description : resources of ATree
      */
     resources?: Partial<typeof Resources.ATree>;
 }
 /**
  * AComponent : ATree
+ *
  * 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.
+ *
  * Basic Usage :
- * (1) const items = [{name: 'Item1', children: [{name: 'Item1-1'}]}];
- * return <ATree useItems={[items, setItems]}/>
  *
- * (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]}/>
+ *     const items = [{name: 'Item1', children: [{name: 'Item1-1'}]}, {name: 'Item2'}, {name: 'Item3'}];
+ *     const [selected, setSelected] = useState<typeof items[0]>(items[0]);
+ *     const [expanded, setExpanded] = useState<typeof items[0]>(items[0]);
+ *     const [searchResult, setSearchResult] = useState<IATreeSearchResult<typeof items[0]> | undefined>(undefined);
+ *
+ *     if (case 1)
+ *       <ATree useItems={[items, undefined]}/>
+ *
+ *     if (case 2)
+ *       <ATree useItems={[items, setItems]}
+ *         useSelect={[selected, setSelected]}/>
  *
- * (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]}/>
+ *     if (case 3)
+ *       <ATree useItems={[items, setItems]}
+ *       useExpand={[expanded, setExpanded]}/>
  *
- * (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]}/>
+ *     if (case 4)
+ *       <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/AWrap/AWrap.d.ts

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