@mingoo/amotify
Version:
UI FW for React
1,347 lines • 50.2 kB
TypeScript
import { Jsmin } from '@mingoo/jsmin';
import { FontAwesomeIconProps } from '@fortawesome/react-fontawesome';
import { IconDefinition } from "@fortawesome/fontawesome-common-types";
import * as FontawesomeCore from '@fortawesome/fontawesome-svg-core';
import React from 'react';
import ReactDOM from 'react-dom';
import * as ReactRouterDOM from 'react-router-dom';
import { ReactElement, Device, Browser } from './_';
import { TagProps } from './property';
export declare namespace config {
interface Methods {
sessionUID: string;
appRootID: string;
appRoot: HTMLElement;
themeColor: TagProps.ThemeColor;
darkMode: TagProps.DarkMode;
roundness: TagProps.Roundness;
device: {
deviceIs: Device;
browserIs: Browser;
isBreakpoint(): boolean;
isPhonepoint(): boolean;
isSystemDarkmode(): boolean;
isPhone: boolean;
isTouchDevice: boolean;
isIOS: boolean;
};
update: {
themeColor(value: TagProps.ThemeColor): void;
darkMode(value: TagProps.DarkMode): void;
roundness(value: TagProps.Roundness): void;
};
variables: {
darkmodeColors: {
light: string;
dark: string;
dim: string;
auto(): string;
};
themeColors: {
[key in TagProps.ThemeColor]: {
alfa(alfa?: number): string;
isBrand: boolean;
isAvocado: boolean;
};
};
};
readExtraCDN(url: string): Promise<boolean>;
}
}
export declare namespace global {
type LaunchRootInput = {
baseElement?: HTMLElement;
};
type LaunchReactApplicationInput = {
baseElement?: HTMLElement | string;
reactElement: ReactElement;
nonRouter?: boolean;
isRoot?: boolean;
appearances?: {
roundness?: TagProps.Roundness;
themeColor?: TagProps.ThemeColor;
darkMode?: TagProps.DarkMode;
};
};
type useStoreParams = {
set(params: {
key: string;
value: any;
privateKey?: string;
}): boolean;
update(params: {
key: string;
value: any;
privateKey?: string;
}): boolean;
get(key: string, privateKey?: string): any;
delete(key: string, privateKey?: string): boolean;
};
type useRecycleParams = {
set(key: string): string;
do(key: string): void;
};
type PageTransitParams = {
open(url: string): void;
pushSync(url: string): void;
pushAsync(url: string): void;
push(url: string, newTab?: boolean): void;
back(): void;
};
namespace StyleConverter {
type ReadStyleSet = {
<T>(params: T): T;
};
type ToClassName = {
<T>(params: T): T;
};
}
interface Methods {
React: typeof React;
ReactDOM: typeof ReactDOM;
ReactRouterDOM: typeof ReactRouterDOM;
StyleConverter: {
ReadStyleSet: StyleConverter.ReadStyleSet;
ToClassName: StyleConverter.ToClassName;
};
pageTransit: PageTransitParams;
useStore: global.useStoreParams;
useRecycle: global.useRecycleParams;
LaunchRoot(params: global.LaunchRootInput): void;
LaunchReactApplication(params: global.LaunchReactApplicationInput): void;
}
}
export declare namespace atoms {
type BoxInput = TagProps.BasicElement & {
children?: ReactElement;
} & React.HTMLAttributes<HTMLDivElement>;
type SpanProps = TagProps.BasicElement & {
children?: ReactElement;
} & React.HTMLAttributes<HTMLSpanElement>;
type ParagraphProps = TagProps.BasicElement & {
children?: ReactElement;
} & React.HTMLAttributes<HTMLParagraphElement>;
type FlexProps = TagProps.BasicElement & {
children?: ReactElement;
} & React.HTMLAttributes<HTMLDivElement>;
type GridProps = TagProps.BasicElement & {
children: ReactElement;
onClick?: {
(event: React.MouseEvent<HTMLDivElement, MouseEvent>): void;
};
} & React.HTMLAttributes<HTMLDivElement>;
namespace FAI {
type Method = React.FC<FAIParams> & Shortcuts;
type FAIParams = TagProps.BasicElement & {
icon: FontawesomeCore.IconProp | IconDefinition;
iconParams?: Omit<FontAwesomeIconProps, 'icon'>;
};
type Shortcuts = {
[key in ShortCutNames]: React.FC<Omit<FAIParams, 'icon'>>;
};
type ShortCutNames = 'User' | 'Times' | 'AngleRight' | 'AngleLeft' | 'AngleUp' | 'AngleDown' | 'ChevronLeft' | 'ChevronRight' | 'ChevronUp' | 'ChevronDown' | 'CaretLeft' | 'CaretRight' | 'CaretUp' | 'CaretDown' | 'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown' | 'Rotate' | 'Redo' | 'Check' | 'CheckCircle' | 'Question' | 'QuestionCircle' | 'Exclamation' | 'ExclamationTriangle' | 'Home' | 'Share' | 'Search' | 'YenSign' | 'Heart' | 'Star' | 'Edit' | 'Pen' | 'Copy' | 'File' | 'TrashAlt' | 'Bars' | 'Download' | 'Link' | 'LinkSlash' | 'ExternalLinkAlt' | 'Gear' | 'Plus' | 'Minus' | 'EllipsisH' | 'EllipsisV' | 'PaperPlane' | 'Image';
}
namespace Image {
type Methods = React.FC<CompInput> & DefaultImages;
type CompInput = TagProps.BasicElement & {
src: string;
alt?: string;
showExpand?: boolean | string;
} & React.HTMLAttributes<HTMLImageElement>;
type DefaultImages = {
uri: {
mingooIcon: string;
comunIcon: string;
comunIconClear: string;
defaultIcon(type: 'image' | 'object' | 'user' | 'group' | 'store'): string;
};
};
}
namespace Logos {
type Methods = {
Icon: (params: Params) => JSX.Element;
Title: (params: Params) => JSX.Element;
Brands: {
MingooIcon: (params: DefaultLogo) => JSX.Element;
MingooTitle: (params: DefaultLogo) => JSX.Element;
MingooLogoH: (params: DefaultLogo) => JSX.Element;
MingooLogoV: (params: DefaultLogo) => JSX.Element;
ComunIcon: (params: DefaultLogo) => JSX.Element;
ComunTitle: (params: DefaultLogo) => JSX.Element;
ComunLogoH: (params: DefaultLogo) => JSX.Element;
ComunLogoV: (params: DefaultLogo) => JSX.Element;
Google: (params: DefaultLogo) => JSX.Element;
Facebook: (params: DefaultLogo) => JSX.Element;
Twitter: (params: DefaultLogo) => JSX.Element;
LINE: (params: DefaultLogo) => JSX.Element;
};
};
type Params = TagProps.BasicElement & {
size?: 'S' | 'R' | 'L' | '2L' | '3L';
color?: 'normal' | 'white';
children?: ReactElement | React.FC<any>;
};
type DefaultLogo = TagProps.BasicElement & {
size?: 'S' | 'R' | 'L' | '2L' | '3L';
color?: 'normal' | 'white';
};
}
type PlaceholderParams = atoms.BoxInput & {
color?: 'cloud' | 'white';
};
type Methods = {
Box: React.FC<atoms.BoxInput>;
Flex: React.FC<atoms.FlexProps>;
FlexBr: React.FC<TagProps.Params>;
Placeholder: React.FC<PlaceholderParams>;
Grid: React.FC<atoms.GridProps>;
FAI: FAI.Method;
Span: React.FC<atoms.SpanProps>;
Paragraph: React.FC<atoms.ParagraphProps>;
Img: atoms.Image.Methods;
Logo: Logos.Methods;
};
}
export declare namespace mols {
namespace Accordion {
type Params = {
defaultOpen?: boolean;
override?: boolean;
accordionID?: string;
slideAnimation?: 'none' | 'fast' | 'slow';
children: ReactElement;
onToggleEvent?: {
(open: boolean): void;
};
} & atoms.BoxInput;
type FNParams = {
fn: {
open(accordionID: string): void;
close(accordionID: string): void;
toggle(accordionID: string): void;
};
};
type SetParams = React.FC<Params> & FNParams;
}
namespace List {
type Params = TagProps.BasicElement & {
rowStyles?: TagProps.Params;
rows: RowsParams[];
};
type RowsParams = {
children: ReactElement;
} & TagProps.BasicElement;
}
type LinkifyTextProps = {
text: string;
placeholder?: ReactElement;
};
type Methods = {
List: React.FC<mols.List.Params>;
Accordion: mols.Accordion.SetParams;
LinkifyText: React.FC<mols.LinkifyTextProps>;
Text: {
NowrapSpan: React.FC<atoms.SpanProps>;
Title: React.FC<atoms.BoxInput>;
SubTitle: React.FC<atoms.BoxInput>;
ThirdTitle: React.FC<atoms.BoxInput>;
Paragraph: React.FC<atoms.BoxInput>;
Normal: React.FC<atoms.BoxInput>;
Description: React.FC<atoms.BoxInput>;
Supplement: React.FC<atoms.BoxInput>;
};
Column: React.FC<atoms.FlexProps>;
Row: {
Center: React.FC<atoms.FlexProps>;
Left: React.FC<atoms.FlexProps>;
Right: React.FC<atoms.FlexProps>;
Separate: React.FC<atoms.FlexProps>;
};
};
}
export declare namespace orgs {
type Methods = {};
}
export declare namespace temps {
type Methods = {};
}
export declare namespace fn {
namespace Layout {
type Methods = {
PageViewController: React.FC<PageViewController.Params>;
TabBar: React.FC<TabBar.Params>;
Plate: React.FC<Plate.Params>;
SwipeView: React.FC<SwipeView.Params>;
PageRouter: React.FC<PageRouter.RouterProps>;
PageNotFound: React.FC<{}>;
RootViewController: RootViewController.Methods;
};
namespace PageViewController {
type Params = {
viewIndex: number;
views: ReactElement[];
wrapper?: {
(view: ReactElement): ReactElement;
};
};
}
namespace TabBar {
type Params = {
tabIndex: number;
tabs: ReactElement[];
onTabChange?: {
(index: number): void;
};
componentDidMount?: {
(): void;
};
} & TagProps.BasicElement;
}
namespace Plate {
type Params = {
size?: 'XS' | 'S' | 'R' | 'L' | 'XL' | 'MAX';
} & atoms.BoxInput;
}
namespace SwipeView {
type Params = TagProps.BasicElement & {
slideIndex?: number;
slides: ReactElement[];
wrapper?: {
(slide: ReactElement): ReactElement;
};
options?: {
onSlideCallback?: {
(index: number): void;
};
visibilitySurroundSlide?: boolean;
autoSwipeSeconds?: number;
loop?: boolean;
disableMousedrag?: boolean;
disableTouch?: boolean;
};
};
}
namespace PageRouter {
type RoutesProps = {
path: string;
content: ReactElement;
};
type Callbacks = {
beforeCallBack?: {
(pathName: string): void;
};
afterCallBack?: {
(pathName: string): void;
};
afterFirstCallBack?: {
(pathName: string): void;
};
};
type RoutesSwitchProps = {
routes: RoutesProps[];
} & Callbacks;
type RouterProps = {
pages: RoutesProps[];
} & Callbacks;
}
namespace RootViewController {
type Methods = {
Base: React.FC<RootViewController.BaseParams>;
TopNavigation: React.FC<atoms.FlexProps>;
SideNavigation: React.FC<atoms.FlexProps & {
baseStyles?: TagProps.Params;
}>;
FooterNavigation: React.FC<atoms.FlexProps & {
baseStyles?: TagProps.Params;
}>;
Comps: {
Button: React.FC<ButtonParams>;
Title: React.FC<atoms.BoxInput>;
Bar: React.FC<atoms.BoxInput>;
};
fn: FNs;
};
type BaseParams = atoms.BoxInput & {
topNavigation?: ReactElement;
sideNavigation?: ReactElement;
footerNavigation?: ReactElement;
};
type ButtonParams = Buttons.ButtonInput & Buttons.Tones.Clear & {
uri?: string;
uriGroup?: (string | RegExp) | (string | RegExp)[];
};
type FNs = {
updateCSSProperty: {
topNav(): void;
footer(): void;
reset(): void;
};
};
}
}
namespace Tables {
type Methods = {
Comps: CompsMethods;
Normal: (props: Normal.Params) => JSX.Element;
Data: Data.Methods;
Drag: (props: Drag.Params) => JSX.Element;
Spread: () => JSX.Element;
};
type CompsMethods = {
Table: React.FC<TableParams>;
Head: React.FC<TableHeadParams>;
Body: React.FC<TableBodyParams>;
Row: React.FC<TRParams>;
TH: React.FC<TableCellParams>;
TD: React.FC<TableCellParams>;
RightIndicator: Uni.CellParams;
};
type DataCompsMethods = {
Search: any;
Info: any;
Paging: any;
};
type customTableHTMLAttributes<T> = Omit<React.TableHTMLAttributes<T>, 'border'>;
type TableParams = TagProps.BasicElement & customTableHTMLAttributes<HTMLTableElement>;
type TableHeadParams = TagProps.BasicElement & customTableHTMLAttributes<HTMLTableSectionElement>;
type TableBodyParams = TagProps.BasicElement & customTableHTMLAttributes<HTMLTableSectionElement>;
type TRParams = TagProps.BasicElement & React.HTMLAttributes<HTMLTableRowElement>;
type TableCellParams = TagProps.BasicElement & React.ThHTMLAttributes<HTMLTableCellElement>;
type Types = 'normal' | 'data' | 'drag' | 'spread';
type Tones = 'border' | 'cellBorder' | 'rowBorder' | 'plain' | 'auto';
type OnRowClick = {
(rowIDOrIndex: any, event: React.MouseEvent<HTMLTableRowElement, MouseEvent>): void;
};
type StylesCallbackInput = {
top: boolean;
bottom: boolean;
left: boolean;
right: boolean;
rowIndex: number;
colIndex: number;
isHeader: boolean;
isBody: boolean;
};
namespace Uni {
type CellParams = TableCellParams & {
type?: 'th' | 'td';
};
type Params = {
tableID?: string;
tone?: Tones;
colLength: number;
cellStyles?: TagProps.Params;
cellClassName?: string;
cellStylesCallback?: {
(params: StylesCallbackInput): TagProps.Params;
};
className?: string;
} & TagProps.Params;
}
namespace Normal {
type CellParams = Uni.CellParams;
type HeadRowParams = CellParams[];
type BodyRowParams = CellParams[] & {
rowID?: string | number;
};
type Params = Uni.Params & {
head: HeadRowParams | false;
rows: BodyRowParams[];
onRowClick?: OnRowClick;
};
}
namespace Drag {
type CellParams = Uni.CellParams;
type HeadRowParams = CellParams[];
type BodyRowParams = CellParams[] & {
rowID?: any;
};
type Params = Uni.Params & {
head: HeadRowParams | false;
rows: BodyRowParams[];
onOrderChanged: {
(orderList: any[]): void;
};
};
}
namespace Data {
type CellParams = TableCellParams & {
type?: 'th' | 'td';
data: string | number;
option?: any;
orderIndex?: string | number;
};
type HeadRowParams = CellParams[];
type BodyRowParams = Array<CellParams> & ArrayObjectParams;
type ArrayObjectParams = {
rowID?: any;
__sys4SearchKey?: string;
checked?: boolean;
filtered?: boolean;
currentPage?: boolean;
};
type Params = Uni.Params & {
tableID?: string;
head: HeadRowParams;
rows: BodyRowParams[];
onRowClick?: OnRowClick;
eventID?: string;
checker?: boolean;
searchKeyword?: string;
filter?: boolean | boolean[];
order?: boolean | boolean[];
defaultOrder?: OrderParams;
pageRowLength: number;
noRecords?: ReactElement;
onOrderChanged?: {
(order: OrderParams): void;
};
};
type Methods = {
(props: Data.Params): JSX.Element;
} & FNs & Comps;
type FNs = {
__memoryID: string;
useStatus(tableID: string): useStatusOutput;
getRowData(tableID: string): BodyRowParams[];
setPageIndex(tableID: string, pageIndex: number): void;
setRowLength(tableID: string, rowLength: number): void;
setSearchKeyword(tableID: string, keyword: string): void;
};
type Comps = {
SearchInput: React.FC<{
tableID: string;
}>;
Info: React.FC<{
tableID: string;
}>;
Paging: React.FC<{
tableID: string;
}>;
RowLength: React.FC<{
tableID: string;
lengthSelect: number[];
}>;
};
type useStatusOutput = {
tableComponentDidMount: boolean;
totalRows: number;
pageRows: number;
filteredRows: number;
searchKeyword: string;
filter: {
enabled: boolean;
column: boolean[];
current: (string[])[];
};
order: {
enabled: boolean;
column: boolean[];
current: fn.Tables.Data.OrderParams;
};
paging: {
rowLength: number;
pageLength: number;
currentPageIndex: number;
};
};
type FilterColumnsProps = {
index: number;
keyword: string;
enabled: boolean;
}[];
type OrderParams = [number, 'ASC' | 'DESC'];
}
namespace Spread {
}
}
namespace Input {
type Methods = {
Plain: React.FC<TagProps.Params & React.InputHTMLAttributes<HTMLInputElement>>;
Hidden: (params: Hidden.PlainParams) => JSX.Element;
Text: Text.Methods;
TextArea: (params: TextArea.PlainParams) => JSX.Element;
Contenteditable: (params: Contenteditable.PlainParams) => JSX.Element;
DigitCharacters: (params: DigitCharacters.PlainParams) => JSX.Element;
Time: Time.Methods;
Select: (params: Select.PlainParams) => JSX.Element;
RichSelect: (params: RichSelect.PlainParams) => JSX.Element;
Radio: (props: List.PlainParams) => JSX.Element;
Checkbox: (props: List.PlainParams) => JSX.Element;
Checker: (params: Checker.PlainParams) => JSX.Element;
Chips: Chips.Methods;
Search: (params: Search.PlainParams) => JSX.Element;
File: Filer.Methods;
Slider: (params: Slider.PlainParams) => JSX.Element;
Switch: (params: Switch.PlainParams) => JSX.Element;
Segmented: Segmented.Types;
Comps: {
RequiredSign: React.FC<atoms.SpanProps>;
RequiredShortSign: React.FC<atoms.SpanProps>;
OmitSign: React.FC<atoms.SpanProps>;
LeftIndicator: React.FC<IndicatorParams>;
RightIndicator: React.FC<IndicatorParams>;
LeftIcon: React.FC<IndicatorParams>;
RightIcon: React.FC<IndicatorParams>;
};
};
type WrapperParams = atoms.BoxInput & {
label?: ReactElement;
labelStyles?: TagProps.Params;
required?: boolean | 'plain' | 'omit';
};
type UniParams = {
name?: string;
form?: string;
status_id?: string;
componentID?: string;
override?: 'force' | 'beforeModified' | 'never';
required?: boolean;
enableFormSubmit?: boolean;
checkValidationAtFirst?: boolean;
onValidate?: Validation.OnValidate;
onUpdateValue?: OnUpdateValue;
onUpdateValidValue?: OnUpdateValue;
};
type CoreParams = UniParams & {
className?: string;
wrapStyles?: TagProps.Params;
} & TagProps.Params;
type OnUpdateValue = {
(data: {
value: any;
componentID: string;
storeData?: plainObject;
eventType: Validation.EventType;
}): void;
};
type BoxTone = 'border' | 'cloud' | 'bottomBorder' | 'plain';
namespace Hidden {
type PlainParams = React.DOMAttributes<HTMLInputElement> & {
componentID?: string;
name?: string;
form?: string;
enableFormSubmit?: boolean;
id?: string;
value?: string | number | plainObject;
};
}
namespace Text {
type Methods = {
Validate(value: any, restrict: Restrict): {
ok: boolean;
body: ReactElement;
};
Normal: (props: OriginParams) => JSX.Element;
Katakana: (props: OriginParams) => JSX.Element;
HankakuKatakana: (props: OriginParams) => JSX.Element;
Number: (props: PlainParams) => JSX.Element;
DigitNumber: (props: PlainParams) => JSX.Element;
Tel: (props: PlainParams) => JSX.Element;
CreditCard: (props: PlainParams) => JSX.Element;
Email: (props: PlainParams) => JSX.Element;
Url: (props: PlainParams) => JSX.Element;
Postal: (props: PlainParams) => JSX.Element;
Password: (props: PlainParams) => JSX.Element;
Money: {
JPY: (props: PlainParams) => JSX.Element;
};
};
type Restrict = 'text' | 'katakana' | 'hankaku.katakana' | 'number' | 'digitNumber' | 'tel' | 'email' | 'url' | 'fileName' | 'password' | 'postal' | 'creditCard';
type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
tone?: BoxTone;
tabIndex?: number;
id?: string;
disabled?: boolean;
min?: number | null;
max?: number | null;
maxLength?: number | null;
autoComplete?: 'off' | 'none' | string;
autoCapitalize?: 'off' | 'none' | string;
clearButton?: boolean;
value?: string | number;
placeholder?: string;
leftIndicator?: ReactElement | false;
rightIndicator?: ReactElement | false;
leftIcon?: ReactElement | false;
rightIcon?: ReactElement | false;
};
type OriginParams = PlainParams & {
restrict?: Restrict;
};
}
namespace TextArea {
type PlainParams = CoreParams & React.TextareaHTMLAttributes<HTMLTextAreaElement> & {
tone?: BoxTone;
tabIndex?: number;
id?: string;
disabled?: boolean;
value?: string | number;
placeholder?: string;
leftIndicator?: ReactElement | false;
rightIndicator?: ReactElement | false;
leftIcon?: ReactElement | false;
rightIcon?: ReactElement | false;
};
}
namespace Contenteditable {
type PlainParams = CoreParams & React.TextareaHTMLAttributes<HTMLDivElement> & {
tone?: BoxTone;
tabIndex?: number;
id?: string;
children?: string;
leftIndicator?: ReactElement | false;
rightIndicator?: ReactElement | false;
leftIcon?: ReactElement | false;
rightIcon?: ReactElement | false;
};
}
namespace DigitCharacters {
type PlainParams = CoreParams & React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> & {
tone?: BoxTone;
combineInput?: boolean;
digits: number;
numericOnly?: boolean;
tabIndex?: number;
id?: string;
value?: string | number;
listStyles?: TagProps.Params;
};
}
namespace Time {
type Methods = {
Clock: (props: PlainParams) => JSX.Element;
Date: (props: PlainParams) => JSX.Element;
Week: (props: PlainParams) => JSX.Element;
Month: (props: PlainParams) => JSX.Element;
Year: (props: PlainParams) => JSX.Element;
DateWareki: (props: DateWarekiParams) => JSX.Element;
Periods: {
Date: (props: PeriodParams) => JSX.Element;
Month: (props: PeriodParams) => JSX.Element;
};
fn: FN;
};
type FN = {
picker: {
launch(params: PickerParams & Omit<Tooltips.Params, 'content'>): void;
remove(tipsID: string): void;
};
};
type Era = 'clock' | 'year' | 'meiji' | 'taisho' | 'shouwa' | 'heisei' | 'reiwa';
type Restrict = 'clock' | 'date' | 'week' | 'month' | 'year' | 'dates' | 'months' | 'dateWareki';
type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
tone?: BoxTone;
tabIndex?: number;
id?: string;
disabled?: boolean;
value?: string | [string, string];
min?: string;
max?: string;
leftIndicator?: ReactElement | false;
rightIndicator?: ReactElement | false;
};
type OriginParams = PlainParams & {
restrict: Restrict;
era?: Era;
};
type DateWarekiParams = PlainParams & {
value?: string;
defaultEra?: 'year' | 'wareki';
};
type PeriodParams = Omit<PlainParams, 'value'> & {
value?: [string, string];
};
type RangeProps = {
type: 'hour' | 'minute' | 'date' | 'month' | 'year' | 'week' | 'dateWareki';
from: number;
length: number;
region?: number;
};
type PickerParams = {
tipsID?: string;
restrict: Restrict;
defaultValue: string | string[];
era?: Era;
min?: string;
max?: string;
onValueUpdate(value: string | [string, string], era: Era): void;
};
}
namespace Select {
type PlainParams = CoreParams & React.DOMAttributes<HTMLSelectElement> & {
tone?: BoxTone;
tabIndex?: number;
id?: string;
disabled?: boolean;
value?: ValueProps;
options: OptionProps[];
placeholder?: string;
leftIndicator?: ReactElement | false;
rightIndicator?: ReactElement | false;
leftIcon?: ReactElement | false;
rightIcon?: ReactElement | false;
enableUnSelected?: boolean;
rightIconStyles?: TagProps.Params;
};
type ValueProps = string | number | boolean | plainObject | void | null;
type OptionProps = {
value: ValueProps;
label: string;
displayLabel?: ReactElement;
};
}
namespace RichSelect {
type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
tone?: BoxTone;
tabIndex?: number;
id?: string;
disabled?: boolean;
value?: ValueProps;
options: OptionProps[];
placeholder?: string;
leftIndicator?: ReactElement | false;
rightIndicator?: ReactElement | false;
leftIcon?: ReactElement | false;
rightIcon?: ReactElement | false;
enableUnSelected?: boolean;
rightIconStyles?: TagProps.Params;
cellStyles?: TagProps.Params;
sheetStyles?: TagProps.Params;
gravityPoint?: number;
};
type ValueProps = string | number | boolean | plainObject | void | null;
type OptionProps = {
type?: 'button' | 'label';
value: ValueProps;
label: ReactElement;
selectedLabel?: ReactElement;
};
}
namespace List {
type ListTone = 'border' | 'cloud' | 'vivid' | 'normal' | 'plain';
type Methods = {
Radio: (props: PlainParams) => JSX.Element;
Checkbox: (props: PlainParams) => JSX.Element;
};
type PlainParams = CoreParams & {
tone?: ListTone;
icon?: boolean;
tabIndex?: number;
id?: string;
iconType?: 'radio' | 'checkbox';
minSelect?: number;
disabled?: boolean;
value?: any | any[];
options: OptionParams[];
hideInput?: boolean;
leftIndicator?: ReactElement | false;
rightIndicator?: ReactElement | false;
cellStyles?: TagProps.Params;
cellClassName?: string;
cellCheckedStyles?: TagProps.Params;
cellCheckedClassName?: string;
defaultActiveStyling?: boolean;
};
type OriginParams = PlainParams & {
type: 'radio' | 'checkbox' | 'checker';
tone: ListTone;
};
type OptionParams = {
value: any;
label: ReactElement;
disabled?: boolean;
className?: string;
checkedStyles?: TagProps.Params;
checkedClassName?: string;
} & TagProps.Params;
}
namespace Chips {
type Methods = React.FC<PlainParams> & {
fn: FNs;
};
type PlainParams = CoreParams & {
tabIndex?: number;
id?: string;
disabled?: boolean;
value?: OptionParams[];
limit?: number;
selectorGravityPoint?: number;
defaultOptions?: OptionParams[];
onDynamicSearch?: onDynamicSearch;
leftIndicator?: ReactElement | false;
rightIndicator?: ReactElement | false;
rightIcon?: ReactElement | false;
leftIcon?: ReactElement | false;
SelectedCellComponent?: SelectedCellComponentInput;
SelectorCellComponent?: SelectorCellComponentInput;
AddButtonComponent?: AddButtonComponentInput;
};
type onDynamicSearch = {
(k: string): Promise<{
options: OptionParams[];
}>;
};
type OptionParams = {
value: any;
label: string;
};
type SelectedCellComponentInput = React.FC<{
removeCallback: Function;
defaultRemoveButton: ReactElement;
openCallback(): void;
value: any;
label: string;
}>;
type SelectorCellComponentInput = React.FC<{
isSelected: boolean;
isFocused: boolean;
value: any;
label: string;
}>;
type AddButtonComponentInput = React.FC<{
selected: OptionParams[];
openCallback(): void;
}>;
type OpenSelectorInput = {
parent: Jsmin.Args;
selectorID: string;
options: OptionParams[];
selected: OptionParams[];
bottomContent?: ReactElement;
gravityPoint?: number;
limit?: number;
onDynamicSearch?: {
(k: string): Promise<{
options: OptionParams[];
}>;
};
onUpdated(params: {
values: any[];
}): void;
onClosed(): void;
SelectorCellComponent?: SelectorCellComponentInput;
};
type FNs = {
openSelector(params: OpenSelectorInput): void;
closeSelector(selectorID: string): void;
updateOptions(selectorID: string, options: OptionParams[]): void;
updateSelected(selectorID: string, selected: OptionParams[]): void;
};
}
namespace Search {
type PlainParams = Chips.PlainParams;
}
namespace Filer {
type Methods = React.FC<PlainParams> & FNs;
type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
tone?: BoxTone;
tabIndex?: number;
id?: string;
disabled?: boolean;
value?: CustomFile[];
limit?: number;
fileNameEdit?: boolean;
systemOnly?: boolean;
accept?: Accept;
cellStyles?: TagProps.Params;
cellClassName?: string;
};
type CustomFile = File & {
id: string;
};
type Accept = 'image' | string;
type FNs = {
fn: {
openDialog(params: {
accept?: Accept;
multiple?: boolean;
}): Promise<File[]>;
};
};
}
namespace Slider {
type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
tabIndex?: number;
id?: string;
disabled?: boolean;
value?: number;
color?: Color;
min: number;
max: number;
step: number;
legends?: {
enable?: boolean;
custom?: LegendsCallback;
showAlways?: boolean;
};
};
type Color = TagProps.ThemeColor | 'theme' | 'posi' | 'nega' | 'warn';
type LegendsCallback = {
(value: number): ReactElement;
};
}
namespace Switch {
type PlainParams = UniParams & React.DOMAttributes<HTMLInputElement> & {
color?: Color;
id?: string;
tabIndex?: number;
appearance?: 'material' | 'applely';
disabled?: boolean;
value?: boolean;
icon?: ReactElement;
};
type Color = TagProps.ThemeColor | 'theme' | 'posi' | 'nega' | 'warn';
}
namespace Segmented {
type Tones = 'Border' | 'ThemeBorder' | 'BottomLine' | 'Cloud' | 'ThemeCloud' | 'WhiteCloud';
type Types = {
Auto: (params: Params) => JSX.Element;
Normal: (params: Params) => JSX.Element;
Cloud: (params: Params) => JSX.Element;
Cloud2: (params: Params) => JSX.Element;
Cloud3: (params: Params) => JSX.Element;
Border: (params: Params) => JSX.Element;
Border2: (params: Params) => JSX.Element;
BottomLine: (params: Params) => JSX.Element;
};
type Params = List.PlainParams;
type ListParams = List.OptionParams[];
}
namespace Checker {
type PlainParams = CoreParams & {
label: ReactElement;
id?: string;
tabIndex?: number;
disabled?: boolean;
value?: boolean;
cellStyles?: TagProps.Params;
cellClassName?: string;
cellCheckedStyles?: TagProps.Params;
cellCheckedClassName?: string;
};
}
namespace Status {
type Plain = {
componentID: string;
dataValue: any;
eventType: Validation.EventType;
eventID: string;
};
type Text = Plain & {
formatValue: any;
prevValue: any;
caretFrom: number;
caretTo: number;
};
type DigitCharacters = Plain & {
formatValue: any;
};
type Time = Plain & {
formatValue: any;
ranges: Time.RangeProps[];
};
type Slider = Plain & {
min: number;
max: number;
step: number;
};
}
namespace Validation {
type EventType = 'init' | 'update' | 'override' | 'refresh';
type Notice = {
type: 'valid' | 'invalid' | 'warn';
label: ReactElement;
};
type Result = {
ok: boolean;
notice: Notice[];
};
type SystemCheck = {
(props: {
value: any;
params: any;
}): Result;
};
type OnValidate = {
(state: {
eventType: EventType;
value: any;
props: plainObject;
}): Promise<Result>;
};
}
type IndicatorParams = TagProps.Params & {
tone?: BoxTone;
className?: string;
children: ReactElement;
};
}
namespace Buttons {
type Methods = Seed & {};
type Seeds = 'Button' | 'Label' | 'Anchor';
type Tones = 'Plain' | 'Link' | 'Normal' | 'Border' | 'Prime' | 'Sub' | 'Clear' | 'FillToBorder' | 'BorderToFill';
type Sizes = 'XS' | 'S' | 'R' | 'L';
type Colors = 'theme' | 'posi' | 'nega' | 'warn' | 'cloud' | 'trans' | 'white' | 'plain';
type Seed = {
Button: Tone<ButtonInput>;
Label: Tone<LabelInput>;
Anchor: Tone<AnchorInput>;
};
type Tone<T> = {
Plain: React.FC<T>;
Link: React.FC<T>;
Normal: Size<T>;
Border: Size<T>;
Prime: Size<T & Tones.Prime>;
Sub: Size<T & Tones.Sub>;
Clear: Size<T & Tones.Clear>;
FillToBorder: Size<T & Tones.FillToBorder>;
BorderToFill: Size<T & Tones.BorderToFill>;
};
type Size<T> = {
XS: React.FC<T>;
S: React.FC<T>;
R: React.FC<T>;
L: React.FC<T>;
};
namespace Tones {
type Plain = {};
type Link = {};
type Normal = {};
type Border = {};
type Prime = {
color?: Colors | TagProps.ThemeColor;
};
type Sub = {
color?: Colors | 'layer';
};
type Clear = {
color?: Colors | 'layer';
};
type FillToBorder = {
color?: Colors;
};
type BorderToFill = {
color?: Colors;
};
}
type UniParams = TagProps.BasicElement & {
tabIndex?: number;
children?: ReactElement;
'aria-label'?: string;
isLocked?: boolean;
isActive?: boolean;
isActiveStyles?: TagProps.Params;
isActiveClassName?: string;
};
type delegateClickEventProps = 'auxEnter' | 'enter' | 'space';
type ButtonInput = UniParams & {
submitOption?: {
formName: string;
acceptInvalidForm?: boolean;
submitDelegationKey?: delegateClickEventProps | delegateClickEventProps[];
callback(form: plainObject, ok: boolean): void;
};
} & React.ButtonHTMLAttributes<HTMLButtonElement>;
type LabelInput = UniParams & {
htmlFor?: string;
} & React.LabelHTMLAttributes<HTMLLabelElement>;
type AnchorInput = UniParams & {
href?: string;
newTab?: boolean;
sync?: boolean;
download?: any;
shiftQueryParams?: boolean;
} & React.ButtonHTMLAttributes<HTMLAnchorElement>;
}
namespace Sheet {
type Methods = {
open(params: Params): void;
refresh(params: Params, open: boolean): void;
resize(params: {
sheetID: string;
size: SizeParams;
}): void;
reposition(sheetID: string): void;
close(key: string, eventType?: 'Escape' | 'pageTransit', force?: boolean): void;
closeGroup(keyGroup: string): void;
closeAll(pageTransit?: boolean): void;
Comps: {
Body: React.FC<atoms.BoxInput>;
};
};
type Params = NormalParams | EdgeParams | CustomParams | ImageParams | Bottom.Params;
type UniParams = {
sheetID?: string;
sheetGroups?: string | string[];
backgroundEffect?: boolean;
content: ReactElement | {
(): JSX.Element;
};
overwrap?: boolean;
close_option?: CloseOptions;
hold_state?: boolean;
openAfter?(): void;
closeAfter?(): void;
} & TagProps.BasicElement;
type SizeParams = 'S' | 'R' | 'L' | '2L' | '3L' | 'MAX';
type CloseOptions = {
pageTransit?: boolean;
escapeKeyDown?: boolean;
aroundClick?: boolean;
elementBlur?: Jsmin.Args;
};
type Sheet = 'normal.topLeft' | 'normal.topCenter' | 'normal.topRight' | 'normal.middleLeft' | 'normal.middleCenter' | 'normal.middleRight' | 'normal.bottomLeft' | 'normal.bottomCenter' | 'normal.bottomRight' | 'drawer.left' | 'drawer.right' | 'drawer.bottom' | 'custom' | 'image';
type NormalParams = UniParams & {
type: Sheet;
size?: SizeParams;
};
type EdgeParams = UniParams & {
type: Sheet;
size?: SizeParams;
};
type CustomParams = UniParams & {
type: 'custom';
parent: Jsmin.Args;
gravityPoint?: number;
};
type ImageParams = Omit<UniParams, 'content'> & {
type: 'image';
src: string | string[];
};
namespace Bottom {
type Sizes = 'S' | 'R' | 'L';
type Params = UniParams & {
type: 'drawer.bottom';
size: Sizes;
sizeChanged?(size: Sizes): void;
baseStyles?: TagProps.Params;
close_option?: CloseOptions & {
swipeDown?: boolean;
};
};
}
}
namespace Tooltips {
type Methods = {
__memoryID: string;
open(params: Params): void;
close(tipsID: string): void;
closeALL(): void;
Comps: {
Body: React.FC<atoms.BoxInput>;
};
};
type Params = {
tipsID?: string;
tipsGroups?: string | string[];
parent: Jsmin.Args;
gravityPoint?: number;
close_option?: Sheet.CloseOptions;
hold_state?: boolean;
content: ReactElement | {
(): JSX.Element;
};
openAfter?(): void;
closeAfter?(): void;
} & TagProps.BasicElement;
}
namespace SnackBar {
type Methods = {
__memoryID: string;
add(props: AddParams): SnackBar.Methods;
remove(snackID: string): SnackBar.Methods;
__launch(): void;
};
type AddParams = Omit<atoms.BoxInput, 'children'> & {
children?: ReactElement | {
(): JSX.Element;
};
customChildren?: {
(params: {
close(): void;
}): JSX.Element;
};
snackID?: string;
secondsToClose?: number;
};
}
namespace Loader {
type Methods = Color & FNs;
type Color = {
Theme: Size<CompInput>;
Posi: Size<CompInput>;
Nega: Size<CompInput>;
Warn: Size<CompInput>;
White: Size<CompInput>;
Cloud: Size<CompInput>;
};
type Size<T> = {
S: React.FC<T>;
R: React.FC<T>;
L: React.FC<T>;
XL: React.FC<T>;
MAX: React.FC<T>;
};
type Sizes = 'S' | 'R' | 'L' | 'XL' | 'MAX';
type Colors = 'theme' | 'posi' | 'nega' | 'warn' | 'white' | 'cloud';
type CompInput = TagProps.Params & {
showInitial?: boolean;
loaderID?: string;
};
type FNs = {
__memoryID: string;
__launch(): void;
fn: {
stopALL(): void;
top: {
active(): void;
stop(): void;
};
corner: {
active(): void;
stop(): void;
};
mini: {
active(loaderID?: string): void;
stop(loaderID?: string): void;
stopALL(): void;
};
};
};
}
namespace Cropper {
type Use = 'square' | 'wallpaper.horizontal' | 'wallpaper.vertical';
type Params = {
use: Use;
develops: DevelopParams[];
onProcessFinished: {
(files: Input.Filer.CustomFile[]): void;
};
};
type DevelopParams = {
size: 'S' | 'R' | 'L';
maxSize?: number;
};
type Methods = {
open(params: Params): void;
};
}
namespace Effects {
type FadeUniParams = atoms.BoxInput & {
animationTime?: number;
animationDelay?: number;
};
type Methods = {
FadeIn: React.FC<FadeUniParams>;
FadeUp: React.FC<FadeUniParams>;
};
}
type Methods = {
Table: fn.Tables.Methods;
Layout: fn.Layout.Methods;
Buttons: fn.Buttons.Methods;
Input: fn.Input.Methods;
Sheet: fn.Sheet.Methods;
SnackBar: fn.SnackBar.Methods