lowcoder-map-component 0.1.1

package/src/index.ts

@@ -0,0 +1,31 @@
+import { BarChartCompWithDefault } from "./comps/Barcharts/comp";
+import { LineChartCompWithDefault } from "./comps/Linecharts/comp";
+import { LineChartv2CompWithDefault } from "./comps/Linechartsv2/comp";
+import { MapChartCompWithDefault } from "./comps/Mapcharts/comp";
+import { MapChartv2CompWithDefault } from "./comps/Mapchartsv2/comp";
+import { MapComponentCompWithDefault } from "./comps/mapComponent/comp";
+import { MixedLineBarChartCompWithDefault } from "./comps/MixedLineBarCharts/comp";
+import { MutilLineChartCompWithDefault } from "./comps/MultiLineCharts/comp";
+import { PercentageChartCompWithDefault } from "./comps/PercentageCharts/comp";
+import { PieChartCompWithDefault } from "./comps/Piecharts/comp";
+import { TablechartCompWithDefault } from "./comps/Tablecharts/comp";
+import { TotalChartCompWithDefault } from "./comps/Totalcharts/comp";
+import { TwoLineChartCompWithDefault } from "./comps/TwoLineCharts/comp";
+import { TabCompWithDefault } from "./comps/tab/comp";
+
+export default {
+  lineChart: LineChartCompWithDefault,
+  lineChartv2: LineChartv2CompWithDefault,
+  twoLineChart: TwoLineChartCompWithDefault,
+  multiLineChart: MutilLineChartCompWithDefault,
+  pieChart: PieChartCompWithDefault,
+  barChart: BarChartCompWithDefault,
+  percentageChart: PercentageChartCompWithDefault,
+  totalChart: TotalChartCompWithDefault,
+  tableChart: TablechartCompWithDefault,
+  mapChart: MapChartCompWithDefault,
+  mapChartv2: MapChartv2CompWithDefault,
+  mixedLineBarChart: MixedLineBarChartCompWithDefault,
+  tab: TabCompWithDefault,
+  mapComponent: MapComponentCompWithDefault,
+};

package/src/types/global.d.ts

@@ -0,0 +1,9 @@
+declare module "*.module.css" {
+  const classes: { [key: string]: string };
+  export default classes;
+}
+
+declare module "*.module.scss" {
+  const classes: { [key: string]: string };
+  export default classes;
+}

package/src/types/lowcoder-sdk.d.ts

@@ -0,0 +1,578 @@
+import { SwitchProps } from "antd";
+
+declare module "lowcoder-sdk" {
+  import React from "react";
+
+  export type ChangeValueAction<T> = (newValue: T) => void;
+
+  export declare abstract class SimpleComp<T> {
+    protected value: T;
+    protected dispatchChangeValueAction: ChangeValueAction<T>;
+    protected abstract getDefaultValue(): T;
+    abstract getPropertyView(): ReactNode;
+  }
+
+  export interface ControlParams {
+    label?: string;
+    value?: any;
+    disabled?: boolean;
+    onChange?: (value: any) => void;
+  }
+
+  export declare function controlItem(
+    options: { filterText?: string },
+    node: ReactNode
+  ): ReactNode;
+
+  /** ========== i18n Utilities ========== */
+  export function getI18nObjects<T>(
+    localeData: Record<string, any>,
+    languages: string
+  ): T;
+  export function getValueByLocale<T>(
+    defaultValue: T,
+    fn: (locale: { language: string }) => T
+  ): T;
+
+  export class Translator<T> {
+    constructor(localeData: Record<string, any>, languages: string);
+    trans(key: string): string;
+    language: string;
+  }
+
+  /** ========== JSON Helpers ========== */
+  export type JSONValue =
+    | string
+    | number
+    | boolean
+    | null
+    | JSONObject
+    | JSONArray;
+  export interface JSONObject {
+    [key: string]: JSONValue;
+  }
+
+  export interface JSONArray extends Array<JSONValue> { }
+
+  /** ========== Option & Dropdown ========== */
+  export interface Option<T = any> {
+    label: string;
+    value: T;
+  }
+  export type OptionsType = Option[];
+
+  export interface DropdownOption {
+    label: string;
+    value: string;
+  }
+  export interface DropdownProps {
+    value: string;
+    options: DropdownOption[];
+    label: string;
+    onChange: (value: string) => void;
+  }
+  export const Dropdown: React.FC<DropdownProps>;
+  export const Switch: React.FC<SwitchProps>;
+
+  /** ========== UI Components ========== */
+  export interface SectionProps {
+    name: string;
+    children?: React.ReactNode;
+  }
+  export const Section: React.FC<SectionProps>;
+
+  export const CustomModal: {
+    confirm: (options: {
+      title: string;
+      content: string;
+      onConfirm: () => void;
+      confirmBtnType?: "delete" | "primary";
+      okText?: string;
+    }) => void;
+  };
+
+  export interface RedButtonProps {
+    onClick: () => void;
+    children?: React.ReactNode;
+  }
+  export const RedButton: React.FC<RedButtonProps>;
+  export const AlignBottom: React.FC<AlignBottomProps>;
+  export const AlignClose: React.FC<AlignCloseProps>;
+  export const AlignTop: React.FC<AlignTopProps>;
+  export const AlignLeft: React.FC<AlignLeftProps>;
+  export const AlignRight: React.FC<AlignRightProps>;
+
+  export interface OptionProps<T> {
+    items: T[];
+    title: string;
+    itemColor?: (item: any) => string;
+    itemTitle: (item: any) => string;
+    popoverTitle?: (item: any) => string;
+    content: (item: any, index: number) => React.ReactNode;
+    onAdd?: () => void;
+    onMove?: (fromIndex: number, toIndex: number) => void;
+    hide?: (item: any) => boolean;
+    onHide?: (item: any, hide: boolean) => void;
+    dataIndex?: (item: any) => number;
+  }
+  export const Option: <T>(props: OptionProps<T>) => JSX.Element;
+
+  export const sectionNames: Record<string, string>;
+  export const hiddenPropertyView: (children: any) => JSX.Element;
+
+  export const InnerGrid: React.ComponentType<any>;
+  export const Drawer: React.ComponentType<any>;
+  export const HintPlaceHolder: React.ComponentType<any>;
+  export const BackgroundColorContext: React.Context<string>;
+
+  //** ========== Hooks ========== */
+  export function useUserViewMode(): boolean;
+
+  /** ========== Theme Context ========== */
+  export interface Theme {
+    theme: { chart?: string;[key: string]: any };
+  }
+
+  export const ThemeContext = React.createContext<Theme | undefined>(undefined);
+
+  /** ========== Action Types & Helpers ========== */
+  export interface CompAction<T = any> {
+    type: string;
+    payload?: T;
+    value?: T;
+  }
+  export interface CustomAction {
+    type: string;
+    value?: any;
+  }
+
+  export type ChildrenMap = Record<string, any>;
+
+  export declare function customAction<T = any>(payload: T): CustomAction;
+  export declare function isMyCustomAction<T>(
+    action: CompAction,
+    type: string
+  ): action is CustomAction & { value: T };
+
+  export const CompActionTypes: {
+    UPDATE_NODES_V2: string;
+    [key: string]: string;
+  };
+
+  export function changeValueAction<T = any>(
+    value: T,
+    check?: boolean
+  ): CompAction<T>;
+  export function changeChildAction<T = any>(
+    childKey: string,
+    value: T,
+    silent?: boolean,
+    name?: string,
+    flag?: boolean
+  ): CompAction<T>;
+  export function wrapChildAction(
+    childKey: string,
+    action: CompAction
+  ): CompAction;
+
+  export function getPromiseAfterDispatch(
+    dispatch: (action: CompAction) => void,
+    action: CompAction,
+    options?: { autoHandleAfterReduce?: boolean }
+  ): Promise<void>;
+
+  /** ========== Utilities ========== */
+  export const chartColorPalette: string[];
+  export function childrenToProps<T extends object>(
+    children: T
+  ): Record<keyof T, any>;
+  export function genRandomKey(): string;
+  export function isNumeric(val: any): boolean;
+
+  /** ========== Config & Builder ========== */
+  export class NameConfig {
+    constructor(name: string, desc?: string, label?: string);
+  }
+  export function depsConfig(config: {
+    name: string;
+    desc: string;
+    depKeys: string[];
+    func: (input: any) => any;
+  }): any;
+
+  export const MultiCompBuilder: new (
+    childrenMap: Record<string, any>,
+    renderer: (props: any) => any
+  ) => {
+    setPropertyViewFn(fn: (children: any, dispatch: DispatchFn) => void): any;
+    build(): any;
+  };
+
+  export function withContext<CompType, ContextKeys extends readonly string[]>(
+    comp: CompType,
+    contextKeys: ContextKeys
+  ): CompType & {
+    context: Record<ContextKeys[number], any>;
+  };
+
+  /** ========== Controls ========== */
+
+  export interface ChangeEventHandlerControl
+    extends Control<(eventName: string) => void> {
+    propertyView(config: {
+      title?: string;
+      label?: string;
+      tooltip?: string;
+      events?: Array<{ label: string; value: string }>;
+    }): React.ReactNode;
+    getView(): (eventName: string) => void;
+  }
+
+  export const ChangeEventHandlerControl: new (
+    params?: any
+  ) => ChangeEventHandlerControl;
+  export interface JSONObjectControl extends Control<object> {
+    propertyView(config: {
+      label?: string;
+      tooltip?: string;
+      placeholder?: string;
+      objType?: string;
+    }): React.ReactNode;
+    getView(): object;
+  }
+  export const JSONObjectControl: new (opts?: any) => JSONObjectControl;
+  export interface ArrayControl<T = any> extends Control<T[]> {
+    propertyView(config: {
+      label?: string;
+      tooltip?: string;
+      placeholder?: string;
+    }): React.ReactNode;
+    getView(): T[];
+  }
+
+  export const ArrayControl: new <T = any>(params?: any) => ArrayControl<T>;
+  export const ExposingStateControl = {
+    propertyView: (opts?: any) => null,
+  } as const;
+  export const ColorControl = {
+    propertyView: (opts?: any) => null,
+  } as Control<string>;
+  export const ColumnOptionControl = {
+    propertyView: (opts?: any) => null,
+  } as Control<string>;
+  export const FunctionControl = {
+    propertyView: (opts?: any) => null,
+  } as Control<any>;
+  export const StringControl = {
+    propertyView: (opts?: any) => null,
+  } as Control<string>;
+  export const NumberControl = {
+    propertyView: (opts?: any) => null,
+  } as Control<number>;
+  export const BoolControl = {
+    propertyView: (opts?: any) => null,
+  } as Control<boolean>;
+  export const ColorOrBoolCodeControl = {
+    propertyView: (opts?: any) => null,
+  } as Control<boolean>;
+  export function dropdownControl<
+    T extends readonly {
+      label: string | JSX.Element;
+      value: string | number | boolean;
+    }[],
+  >(options: T, defaultValue?: string | number | boolean): JSX.Element;
+  export const BoolCodeControl: React.ComponentType<any>;
+  export const RefControl: React.ComponentType<any>;
+  export const StringStateControl: React.ComponentType<any>;
+
+  export function EventOptionControl(label: string): any;
+  export function EventControl(label: string): any;
+  export function switchControl(label: string, defaultValue?: boolean): any;
+  export function switchAndTextControl(
+    label: string,
+    defaultValue: boolean,
+    inputProps?: any
+  ): any;
+  export function numberControl(
+    label: string,
+    defaultValue?: number,
+    options?: { min?: number; max?: number }
+  ): any;
+  export function multiCompBuilder<T>(builders: T): any;
+  export function text(label: string): any;
+
+  export declare function list<T>(comp: T): any;
+  export declare function stateComp<T>(initialValue: T): any;
+  export declare function jsonControl<T = any>(
+    transform: (value: any) => T,
+    defaultValue?: T
+  ): any;
+  export function eventHandlerControl<T extends readonly any[]>(events: T): any;
+
+  export function stringExposingStateControl(
+    name: string,
+    defaultValue?: string
+  ): ExposingStateControl<string>;
+
+  export interface EventHandlerControl {
+    propertyView: () => React.ReactNode;
+  }
+
+  export function valueComp<T>(defaultValue: T): any;
+  export function uiChildren<T extends Record<string, any>>(children: T): T;
+
+  export type Control<T = any> = {
+    getView: () => T;
+    onChange: (value: T) => void;
+    propertyView?: (options?: T) => React.ReactNode;
+    getPropertyView: (options?: T) => void;
+    change?: (value: T) => void;
+    children?: any;
+  };
+
+  export const BooleanStateControl: Control<boolean>;
+  // declare const AutoHeightControl: ControlComponent<AutoHeightType>;
+  export type AutoHeightType = "auto" | "fixed";
+
+  export const AutoHeightControl = {
+    propertyView: (opts?: any) => null,
+  } as Control<AutoHeightType>;
+
+  export const stringStateControl: (label?: string) => Control<string>;
+  export const jsonObjectExposingStateControl: (
+    defaultValue?: any
+  ) => Control<any>;
+
+  /** ========== Type Helpers ========== */
+  export type ConstructorToComp<T> = T extends new (...args: any[]) => infer R
+    ? R
+    : never;
+  export type ConstructorToDataType<T> = T extends new (...args: any[]) => {
+    getView(): infer D;
+  }
+    ? D
+    : never;
+  export type ConstructorToView<T> = T extends new (...args: any[]) => {
+    getPropertyViewWithData(...args: any[]): infer V;
+  }
+    ? V
+    : never;
+  export type ValueFromOption<T extends readonly { value: any }[]> =
+    T[number]["value"];
+  export const EchartDefaultChartStyle: EchartDefaultChartStyleType = {};
+  export const EchartDefaultTextStyle: EchartDefaultTextStyleType = {};
+  export const clickEvent: ClickEventType = "click";
+  export const styleControl: StyleControlFn = (style, key) => style;
+  export const toArray: ToArrayFn = (value) =>
+    Array.isArray(value) ? value : [value];
+
+  export const toJSONObjectArray: ToJSONObjectArrayFn = (value) =>
+    Array.isArray(value) ? value : [value];
+
+  export const toJSONObject: ToJSONObjectFn = (value) =>
+    Array.isArray(value) ? value[0] : value;
+
+  export const toObject: ToObjectFn = (value) => value;
+  export const withType: WithTypeFn = (optionMap, defaultKey) =>
+    optionMap[defaultKey];
+
+  export type RecordConstructorToView<T extends Record<string, any>> = {
+    [K in keyof T]: T[K] extends { propertyView: (...args: any) => any }
+    ? T[K] extends { value: infer V }
+    ? V
+    : any
+    : T[K] extends (...args: any) => any
+    ? ReturnType<T[K]>
+    : any;
+  };
+
+  export type RecordConstructorToComp<T extends Record<string, any>> = {
+    [K in keyof T]: T[K];
+  };
+
+  // ---- Exposing / Method ----
+  export function withMethodExposing(comp: any, methods: any[]): any;
+  export function withViewFn<T>(comp: T, fn: (comp: any) => JSX.Element): T;
+  export function withExposingConfigs<T>(comp: T, configs: any[]): T;
+  export function withDefault<T>(comp: T, defaultValue: any): T;
+
+  // --------- Utils ----------
+  export function getData<T = any>(data: T): { data: T };
+
+  // --------- Grid Utils ----------
+  export function gridItemCompToGridItems(items: any): any[];
+
+  // --------- Constants ----------
+  export const Layers: {
+    drawer: number;
+  };
+
+  export const DrawerStyle: any;
+  export const PositionControl: Control<string>;
+
+  // --------- Container Builder ----------
+  export class ContainerCompBuilder {
+    constructor(
+      children: Record<string, any>,
+      render: (props: any, dispatch: DispatchFn) => React.ReactNode
+    );
+    setPropertyViewFn(fn: (children: any) => React.ReactNode): this;
+    build(): any;
+  }
+
+  // --------- Event Controls ----------
+  export const MeetingEventHandlerControl: Control<any>;
+
+  export const ButtonStyle = {
+    background,
+    border,
+    text,
+    radius,
+    margin,
+    padding,
+  } as const;
+
+  export type GenColorFn = (baseColor: string) => string;
+  export const genHoverColor: GenColorFn;
+  export const genActiveColor: GenColorFn;
+
+  export type FocusWithOptions = (options?: FocusOptions) => void;
+  export type BlurMethod = () => void;
+  export type ClickMethod = () => void;
+
+  export const focusWithOptions: FocusWithOptions;
+  export const blurMethod: BlurMethod;
+  export const clickMethod: ClickMethod;
+
+  export type RefMethod = (...args: any[]) => void;
+  export type RefMethods = (methods: RefMethod[]) => Record<string, RefMethod>;
+  export const refMethods: RefMethods;
+
+  export type MigrateOldData<T> = (
+    control: T,
+    fixOldData: (oldData: any) => any
+  ) => T;
+  export const migrateOldData: MigrateOldData<any>;
+
+  export const EditorContext: React.Context<any>;
+
+  // styled
+  export const styled: {
+    video: (
+      styles: TemplateStringsArray,
+      ...args: any[]
+    ) => React.ComponentType<any>;
+    div: (
+      styles: TemplateStringsArray,
+      ...args: any[]
+    ) => React.ComponentType<any>;
+  };
+
+  export const CommonNameConfig: NameConfig[];
+
+  export const showLabelPropertyView: (children: any) => JSX.Element = (
+    children
+  ) => {
+    return children;
+  };
+
+  export type DispatchFn = (action: { type: string; payload?: any }) => void;
+
+  export interface UICompBuilder<TChildren, TProps> {
+    constructor(
+      children: TChildren,
+      renderFn: (props: TProps, dispatch: DispatchFn) => React.ReactNode
+    );
+    setPropertyViewFn(
+      fn: (children: TChildren, dispatch: DispatchFn) => React.ReactNode
+    ): UICompBuilder<TChildren, TProps>;
+    build(): any;
+  }
+
+  export declare const UICompBuilder: new <TChildren, TProps>(
+    children: TChildren,
+    renderFn: (props: TProps, dispatch: DispatchFn) => React.ReactNode
+  ) => UICompBuilder<TChildren, TProps>;
+
+  export declare function booleanControl(defaultValue?: boolean): any;
+
+  export declare function jsonControl(defaultValue: any): any;
+
+  export declare function stringControl(defaultValue: string): any;
+
+  export declare function animationStyleControl(options?: any): any;
+
+  export declare function eventModalStyleControl(options?: any): any;
+
+  export declare const styleControlObject: any;
+  export declare const animationStyleControlObject: any;
+  export declare const eventModalStyleControlObject: any;
+
+  // ======= State Comp =======
+  export declare function stateComp<T>(
+    initialValue: T,
+    options?: any,
+    initState: (props: T) => any,
+    mapStateToProps: (state: any) => Partial<T>,
+    mapDispatchToProps: (dispatch: DispatchFn) => any
+  ): {
+    getView: () => T;
+    setView: (value: T) => void;
+  };
+
+  export type CalendarStyle = {
+    background?: string;
+    textSize?: string;
+    color?: string;
+    [key: string]: any;
+  };
+
+  export type AnimationStyle = {
+    animationType?: string;
+    animationDelay?: string;
+    animationDuration?: string;
+    animationIterationCount?: string;
+  };
+
+  export type EventModalStyle = {
+    background?: string;
+    borderRadius?: string;
+    [key: string]: any;
+  };
+
+  export type EventType = {
+    id: string;
+    label: string;
+    detail?: string;
+    start: string;
+    end: string;
+    allDay?: boolean;
+    groupId?: string;
+    resourceId?: string;
+    color?: string;
+    backgroundColor?: string;
+    titleColor?: string;
+    detailColor?: string;
+    titleFontWeight?: string;
+    titleFontStyle?: string;
+    detailFontWeight?: string;
+    detailFontStyle?: string;
+    animation?: string;
+    animationDelay?: string;
+    animationDuration?: string;
+    animationIterationCount?: string;
+  };
+}
+
+/** ========== AxisFormatterComp ========== */
+export interface AxisFormatterCompProps {
+  value: string;
+}
+
+export declare const AxisFormatterComp: {
+  new(): {
+    getView(): string;
+    getPropertyView(): React.ReactNode;
+    dispatch: (action: CompAction) => void;
+  };
+};