ados-rcm 1.0.9 → 1.0.12

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

@@ -5,6 +5,7 @@ import { Resources } from '../AResource/AResource';
 export interface IFileRendererProps {
     /**
      * file : File
+     *
      * Description : file to render
      */
     file: File;
@@ -12,32 +13,33 @@ export interface IFileRendererProps {
 export interface IAFileBoxProps extends IABaseProps {
     /**
      * useFile : TUseValues<File | null>
+     *
      * Description : useFile of AFileBox
-     * Basic Usage :
-     * (1) const [file, setFile] = useState<File | null>(null);
-     * <AFileBox useFile={[file, setFile]}/>
      */
     useFile: TUseValues<File | null>;
     /**
      * FileRenderer? : (props: IFileRendererProps) => React.ReactNode
+     *
      * Description : FileRenderer of AFileBox
-     * Basic Usage :
-     * (1) <AFileBox FileRenderer={file => <div>{file.name}</div>}/>
      */
     FileRenderer?: (props: IFileRendererProps) => React.ReactNode;
     /**
      * resources? : typeof Resources.AFileBox
+     *
      * Description : resources of AFileBox
-     * Basic Usage :
-     * (1) <AFileBox resources={{'or Drag & Drop': 'or Drag the File and Drop it here'}}/>
      */
     resources?: typeof Resources.AFileBox;
 }
 /**
  * AComponent : AFileBox
+ *
  * Description : AFileBox is a file box component that can select a file.
+ *
  * Basic Usage :
- * (1) const [file, setFile] = useState<File | null>(null);
- * return <AFileBox useFile={[file, setFile]}/>
+ *
+ *     const [file, setFile] = useState<File | null>(null);
+ *
+ *     if (case 1)
+ *       <AFileBox useFile={[file, setFile]}/>
  */
 export declare const AFileBox: ({ useFile, FileRenderer, resources: extResources, ...props }: IAFileBoxProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -4,16 +4,19 @@ import { TCanCallback } from '../../AUtils/cbF';
 export interface IAFloatMenuActions {
     /**
      * open : () => void
+     *
      * Description : open AFloatMenu
      */
     open: () => void;
     /**
      * close : () => void
+     *
      * Description : close AFloatMenu
      */
     close: () => void;
     /**
      * toggle : () => void
+     *
      * Description : toggle AFloatMenu
      */
     toggle: () => void;
@@ -21,11 +24,13 @@ export interface IAFloatMenuActions {
 export interface IAFloatMenuContentProps {
     /**
      * defKey : TIdx
+     *
      * Description : defKey of AFloatMenu
      */
     defKey: TIdx;
     /**
      * def : IAFloatMenuDef
+     *
      * Description : def of AFloatMenu
      */
     def: IAFloatMenuDef;
@@ -33,16 +38,19 @@ export interface IAFloatMenuContentProps {
 export interface IAFloatMenuDef {
     /**
      * noDisplay? : boolean
+     *
      * Description : decides whether to display the menu or not
      */
     noDisplay?: boolean;
     /**
      * isDisabled? : boolean
+     *
      * Description : decides whether the menu is disabled or not
      */
     isDisabled?: boolean;
     /**
      * content? : TCanCallback<IAFloatMenuContentProps, React.ReactNode>
+     *
      * Description : content of AFloatMenu
      */
     content?: TCanCallback<IAFloatMenuContentProps, React.ReactNode>;
@@ -53,79 +61,55 @@ export type TAFloatMenuDefs = {
 export interface IAFloatMenuProps {
     /**
      * defs : TAFloatMenuDefs
+     *
      * Description : defs of AFloatMenu
-     * Basic Usage :
-     * (1) const defs = {
-     *   'testDefKey' : {
-     *     content : ({defKey, def}) => <div>{defKey}</div>,
-     *   },
-     *   'testDefKey2' : {}
-     * }
-     * return <AFloatMenu defs={defs}/>
      */
     defs: TAFloatMenuDefs;
     /**
      * defaultDef? : IAFloatMenuDef
+     *
      * Description : defaultDef of AFloatMenu. it will affect all defs.
-     * Basic Usage :
-     * (1) const defs = {
-     *   'testDefKey' : {
-     *     content : ({defKey, def}) => <div>{defKey}</div>,
-     *   },
-     *   'testDefKey2' : {}
-     * }
-     * const defaultDef = {
-     *  content : ({defKey, def}) => <div>I am test defaultDef!</div>,
-     * }
-     * return <AFloatMenu defs={defs} defaultDef={defaultDef}/> // testDefKey2 will render 'I am test defaultDef!'
      */
     defaultDef?: IAFloatMenuDef;
     /**
      * anchorRef : React.RefObject<HTMLElement>
+     *
      * Description : anchorRef of AFloatMenu
-     * Basic Usage :
-     * (1) const anchorRef = useRef<HTMLDivElement>(null);
-     * return <>
-     *  <div ref={anchorRef}>I am anchor</div>
-     *  <AFloatMenu anchorRef={anchorRef}/>
-     * </>
      */
     anchorRef: React.RefObject<HTMLElement>;
     /**
      * position? : EDir12
+     *
      * Description : position of AFloatMenu based on anchorRef
-     * Basic Usage :
-     * (1) <AFloatMenu position={EDir12.W}/>
      */
     position?: EDir12;
     /**
      * actionRef? : TActionRef<IAFloatMenuActions>
+     *
      * Description : actionRef of AFloatMenu
-     * Basic Usage :
-     * (1) const actionRef = useRef<IAFloatMenuActions>();
-     * return <AFloatMenu actionRef={actionRef}/>
      */
     actionRef?: TActionRef<IAFloatMenuActions>;
 }
 /**
  * AComponent : AFloatMenu
+ *
  * Description : AFloatMenu is a floating component with menues to click.
+ *
  * Basic Usage :
- * (1) const defs = {
- *  'testDefKey' : {
- *     content : ({defKey, def}) => <div>{defKey}</div>,
- *   },
- *   'testDefKey2' : {}
- * }
- * const defaultDef = {
- *   content : ({defKey, def}) => <div>I am test defaultDef!</div>,
- * }
- * const anchorRef = useRef<HTMLDivElement>(null);
- * return (
- *   <>
- *     <div ref={anchorRef}>I am anchor</div>
- *     <AFloatMenu defs={defs} defaultDef={defaultDef} anchorRef={anchorRef}/>
- *   </>
- * )
+ *
+ *     const defs = {
+ *       testDefKey : {
+ *         content : ({defKey, def}) => <div>{defKey}</div>,
+ *       },
+ *       testDefKey2 : {}
+ *     }
+ *     const defaultDef = {
+ *       content : ({defKey, def}) => <div>I am test defaultDef!</div>,
+ *     }
+ *     const anchorRef = useRef<HTMLDivElement>(null);
+ *
+ *     if (case 1)
+ *       <div ref={anchorRef}>I am anchor</div>
+ *       <AFloatMenu defs={defs} defaultDef={defaultDef} anchorRef={anchorRef}/>
  */
 export declare const AFloatMenu: ({ defs: extDefs, defaultDef: extDefaultDef, anchorRef, actionRef, position, }: IAFloatMenuProps) => import("react").ReactPortal | null;

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

@@ -1,44 +1,53 @@
 import { IABaseProps } from '../ABase/ABase';
 /**
  * AComponent : AFrame : RowFrame
+ *
  * Description : RowFrame is a frame component that is displayed as a row and aligned center.
+ *
  * Basic Usage :
- * (1) <RowFrame>
- *   Items
- *   <div>Item1</div>
- *   <AICon icon="Alert"/>
- * </RowFrame>
+ *
+ *     if (case 1)
+ *       <RowFrame>
+ *         Items
+ *         <div>Item1</div>
+ *         <AICon icon="Alert"/>
+ *       </RowFrame>
  */
 export declare const RowFrame: (props: IABaseProps) => import("react/jsx-runtime").JSX.Element;
 /**
  * AComponent : AFrame : ColFrame
+ *
  * Description : ColFrame is a frame component that is displayed as a column and aligned center.
+ *
  * Basic Usage :
- * (1) <ColFrame>
- *   Items
- *   <div>Item1</div>
- *   <AICon icon="Alert"/>
- * </ColFrame>
+ *
+ *     if (case 1)
+ *       <ColFrame>
+ *         Items
+ *         <div>Item1</div>
+ *         <AICon icon="Alert"/>
+ *       </ColFrame>
  */
 export declare const ColFrame: (props: IABaseProps) => import("react/jsx-runtime").JSX.Element;
 interface IOverflowFrameProps extends IABaseProps {
     /**
      * noOverflowTooltip? : boolean
+     *
      * Description : decides whether to display tooltip when overflowed or not
-     * Basic Usage :
-     * (1) <OverflowFrame noOverflowTooltip>
-     *  Long TextTextTextTextTextTextTextTextTextText
-     * </OverflowFrame>
      */
     noOverflowTooltip?: boolean;
 }
 /**
  * AComponent : AFrame : OverflowFrame
+ *
  * Description : OverflowFrame is a frame component that is text-ellipsis and shows tooltips when overflowed.
+ *
  * Basic Usage :
- * (1) <OverflowFrame>
- *  Long TextTextTextTextTextTextTextTextTextText
- * </OverflowFrame>
+ *
+ *     if (case 1)
+ *       <OverflowFrame>
+ *         Long TextTextTextTextTextTextTextTextTextText
+ *       </OverflowFrame>
  */
 export declare const OverflowFrame: ({ tooltip: extTooltip, children, abaseRef, className, noOverflowTooltip, ...props }: IOverflowFrameProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,11 +1,15 @@
 /**
  * AComponent : AGrow
+ *
  * Description : AGrow is a frame component that grows flexibly.
+ *
  * Basic Usage :
- * (1) <div style={{display: 'flex', flexGrow: 1}}>
- *   Left Item
- *   <AGrow/>
- *   Right Item
- * </div>
+ *
+ *     if (case 1)
+ *       <div style={{display: 'flex', flexGrow: 1}}>
+ *         Left Item
+ *         <AGrow/>
+ *         Right Item
+ *       </div>
  */
 export declare const AGrow: () => import("react/jsx-runtime").JSX.Element;

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

@@ -6,17 +6,20 @@ export type TIcons = keyof typeof AIcons;
 export interface IAIconProps extends IASVGProps {
     /**
      * icon : TIcons
+     *
      * Description : icon to render
-     * Basic Usage :
-     * (1) <AIcon icon="Alert"/>
      */
     icon: TIcons;
 }
 /**
  * AComponent : AIcon
+ *
  * Description : AIcon is an icon component that can render icons.
+ *
  * Basic Usage :
- * (1) <AIcon icon="Alert"/>
+ *
+ *     if (case 1)
+ *       <AIcon icon="Alert"/>
  */
 export declare const AIcon: ({ icon, svgRef, ...rest }: IAIconProps) => import("react/jsx-runtime").JSX.Element;
 export declare const AIcons: Readonly<{

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

@@ -6,110 +6,99 @@ export type TInputType = 'Primary' | 'Secondary' | 'Error';
 export interface IAInputProps extends IABaseProps, IAWrapProps {
     /**
      * onEnterPress? : (value: string) => void
+     *
      * Description : onEnterPress of AInput
-     * Basic Usage :
-     * (1) <AInput onEnterPress={value => console.log(value)}/>
      */
     onEnterPress?: (value: string) => void;
     /**
      * type? : TInputType = 'Primary'
+     *
      * Description : type of AInput
-     * Basic Usage :
-     * (1) <AInput type="Secondary"/>
      */
     type?: TInputType;
     /**
      * inputRef? : React.RefObject<HTMLInputElement>
+     *
      * Description : inputRef of AInput
-     * Basic Usage :
-     * (1) const inputRef = useRef<HTMLInputElement>(null);
-     * <AInput inputRef={inputRef}/>
      */
     inputRef?: React.RefObject<HTMLInputElement>;
     /**
      * useValue? : TUseValues<string>
+     *
      * Description : useValue of AInput
-     * Basic Usage :
-     * (1) const [value, setValue] = useState<string>('');
-     * <AInput useValue={[value, setValue]}/>
      */
     useValue?: TUseValues<string>;
     /**
      * isReadonly? : boolean
+     *
      * Description : decides whether the input is readonly or not
-     * Basic Usage :
-     * (1) <AInput isReadonly/>
      */
     isReadonly?: boolean;
     /**
      * placeholder? : string
+     *
      * Description : placeholder of AInput
-     * Basic Usage :
-     * (1) <AInput placeholder="Placeholder"/>
      */
     placeholder?: string;
     /**
      * maxLength? : number
+     *
      * Description : maxLength of AInput
-     * Basic Usage :
-     * (1) <AInput maxLength={10}/>
      */
     maxLength?: number;
     /**
      * tabIndex? : number
+     *
      * Description : tabIndex of AInput
-     * Basic Usage :
-     * (1) <AInput tabIndex={1}/>
      */
     tabIndex?: number;
     /**
      * autoFocus? : boolean
+     *
      * Description : decides whether the input is focused or not
-     * Basic Usage :
-     * (1) <AInput autoFocus/>
      */
     autoFocus?: boolean;
     /**
      * isPassword? : boolean
+     *
      * Description : decides whether the input is password or not. if true, values will be masked.
-     * Basic Usage :
-     * (1) <AInput isPassword/>
      */
     isPassword?: boolean;
     /**
      * autoComplete? : string = 'off'
+     *
      * Description : autoComplete of AInput
-     * Basic Usage :
-     * (1) <AInput autoComplete="on"/>
      */
     autoComplete?: string;
     /**
      * LeftAddon? : React.ReactNode
+     *
      * Description : LeftAddon of AInput
-     * Basic Usage :
-     * (1) <AInput LeftAddon={<AICon icon="Search"/>}/>
      */
     LeftAddon?: React.ReactNode;
     /**
      * RightAddon? : React.ReactNode
+     *
      * Description : RightAddon of AInput
-     * Basic Usage :
-     * (1) <AInput RightAddon={<AICon icon="Search"/>}/>
      */
     RightAddon?: React.ReactNode;
     /**
      * inputProps? : React.InputHTMLAttributes<HTMLInputElement>
+     *
      * Description : inputProps of AInput
-     * Basic Usage :
-     * (1) <AInput inputProps={{onFocus: () => console.log('focus')}}/>
      */
     inputProps?: React.InputHTMLAttributes<HTMLInputElement>;
 }
 /**
  * AComponent : AInput
+ *
  * Description : AInput is an input 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 <AInput useValue={[value, setValue]}/>
+ *
+ *     const [value, setValue] = useState<string>('');
+ *
+ *     if (case 1)
+ *       <AInput useValue={[value, setValue]}/>
  */
 export declare const AInput: ({ onEnterPress, type, inputRef, useValue, isReadonly, placeholder, maxLength, tabIndex, autoFocus, isPassword, autoComplete, LeftAddon, RightAddon, inputProps, wrapProps, helperText, label, wrapType, ...abaseProps }: IAInputProps) => React.ReactNode;

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

@@ -17,16 +17,19 @@ import { TIdx } from '../ATypes/ATypes';
 export interface IAListViewContentProps<T extends IObject> {
     /**
      * defKey : TIdx
+     *
      * Description : defKey of AListView
      */
     defKey: TIdx;
     /**
      * item : T
+     *
      * Description : item of AListView
      */
     item: T;
     /**
      * def : IAListViewDef<T>
+     *
      * Description : def of AListView
      */
     def: IAListViewDef<T>;
@@ -34,11 +37,13 @@ export interface IAListViewContentProps<T extends IObject> {
 export interface IAListViewDef<T extends IObject> {
     /**
      * label? : TCanCallback<IAListViewContentProps<T>, React.ReactNode>
+     *
      * Description : label of AListView
      */
     label?: TCanCallback<IAListViewContentProps<T>, React.ReactNode>;
     /**
      * content? : TCanCallback<IAListViewContentProps<T>, React.ReactNode>
+     *
      * Description : content of AListView
      */
     content?: TCanCallback<IAListViewContentProps<T>, React.ReactNode>;
@@ -51,40 +56,46 @@ export type TAListViewDefs<T extends IObject> = {
 export interface IAListViewProps<T extends IObject> extends IABaseProps {
     /**
      * defs : TAListViewDefs<T>
+     *
      * Description : defs of AListView
-     * Basic Usage :
-     * const defs = {
-     *  'Name': {label: ({item}) => item.name},
-     *  'Age': {content: ({item}) => item.age},
-     * }
-     * <AListView defs={defs} item={{name: 'John', age: 20}}/>
      */
     defs: TAListViewDefs<T>;
     /**
      * defaultDef? : IAListViewDef<T>
+     *
      * Description : defaultDef of AListView. it affects no all defs, and can be overridden by each def.
-     * Basic Usage :
-     * (1) const defaultDef = {label: ({defKey}) => defKey};
-     * <AListView defs={{'Name': {content: ({item}) => item.name}}} defaultDef={defaultDef}/>
      */
     defaultDef?: IAListViewDef<T>;
     /**
      * item : T
+     *
      * Description : item of AListView
-     * Basic Usage :
-     * (1) <AListView defs={{'Name': {content: ({item}) => item.name}}} item={{name: 'John'}}/>
      */
     item: T;
 }
 /**
  * AComponent : AListView
+ *
  * Description : AListView is a list view component that can show the key:values of items
+ *
  * Basic Usage :
- * (1) const defs = {
- *  'Name': {label: ({item}) => item.name},
- *  'Age': {content: ({item}) => item.age},
- * }
- * const item = {name: 'John', age: 20};
- * return <AListView defs={defs} item={item}/>
+ *
+ *     const defs = {
+ *       name : {label: 'Name~'}
+ *       age : {content: ({item}) => item.age},
+ *       height : {}
+ *       description : {}
+ *     }
+ *     const defaultDef = {
+ *       label: ({defKey}) => 'label is ' + defKey,
+ *       content: ({defKey, item}) => 'content is ' + item[defKey]
+ *     }
+ *     const user = {name: 'John', age: 20, height: 180, description: 'good'}
+ *
+ *     if (case 1)
+ *       <AListView defs={defs} item={user}/>
+ *
+ *     if (case 2)
+ *       <AListView defs={defs} item={user} defaultDef={defaultDef}/>
  */
 export declare const AListView: <T extends IObject>({ defs: extDefs, defaultDef: extDefaultDef, item, ...abaseProps }: IAListViewProps<T>) => import("react/jsx-runtime").JSX.Element;