@coding-flow/flow-design 0.0.1

package/dist/script-components/components/condition/components/condition-relation/render.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { ConditionRelationProps, LogicalRelation } from "../../typings";
+export declare class RelationRender {
+    private relations;
+    private constructor();
+    private init;
+    private static readonly instance;
+    static getInstance(): RelationRender;
+    render(props: ConditionRelationProps): import("react/jsx-runtime").JSX.Element | undefined;
+    renderList(relations: LogicalRelation[]): React.ReactNode[];
+}

package/dist/script-components/components/condition/components/condition-relation/render.js

@@ -0,0 +1,49 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { RelationOr } from "./or.js";
+import { RelationAnd } from "./and.js";
+import { RelationGroup } from "./group.js";
+import { RelationAction } from "./action.js";
+import { RelationCondition } from "./condition.js";
+class RelationRender {
+    relations;
+    constructor(){
+        this.relations = new Map();
+        this.init();
+    }
+    init() {
+        this.relations.clear();
+        this.relations.set("or", RelationOr);
+        this.relations.set("and", RelationAnd);
+        this.relations.set("group", RelationGroup);
+        this.relations.set("action", RelationAction);
+        this.relations.set("condition", RelationCondition);
+    }
+    static instance = new RelationRender();
+    static getInstance() {
+        return this.instance;
+    }
+    render(props) {
+        const type = props.current.type;
+        const RelationView = this.relations.get(type);
+        if (RelationView) return /*#__PURE__*/ jsx(RelationView, {
+            ...props
+        });
+    }
+    renderList(relations) {
+        const list = [];
+        const length = relations.length;
+        for(let i = 0; i < length; i++){
+            const left = i - 1 >= 0 ? relations[i - 1] : void 0;
+            const right = i + 1 > length ? void 0 : relations[i + 1];
+            const current = relations[i];
+            list.push(this.render({
+                leftRelation: left,
+                current: current,
+                rightRelation: right
+            }));
+        }
+        return list;
+    }
+}
+export { RelationRender };

package/dist/script-components/components/condition/context/index.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { Presenter } from "../presenters";
+import { ConditionState, ConditionViewProps } from "../typings";
+export declare class ConditionContextScope {
+    private readonly presenter;
+    private readonly props;
+    constructor(presenter: Presenter, props: ConditionViewProps);
+    syncState(state: ConditionState): void;
+    getPresenter(): Presenter;
+    initState(initData: any): void;
+    clearState(): void;
+}
+export declare const ConditionContext: React.Context<ConditionContextScope | undefined>;

package/dist/script-components/components/condition/context/index.js

@@ -0,0 +1,23 @@
+import react from "react";
+class ConditionContextScope {
+    presenter;
+    props;
+    constructor(presenter, props){
+        this.presenter = presenter;
+        this.props = props;
+    }
+    syncState(state) {
+        this.presenter.syncState(state);
+    }
+    getPresenter() {
+        return this.presenter;
+    }
+    initState(initData) {
+        this.presenter.initState(initData);
+    }
+    clearState() {
+        this.presenter.clearState();
+    }
+}
+const ConditionContext = react.createContext(void 0);
+export { ConditionContext, ConditionContextScope };

package/dist/script-components/components/condition/convertor/groovy.d.ts

@@ -0,0 +1,10 @@
+import { ConditionState } from "../typings";
+export declare class ConditionGroovyConvertor {
+    private readonly state;
+    constructor(state: ConditionState);
+    isError(): boolean;
+    private getMeta;
+    private getTitle;
+    private getReturn;
+    getScript(): string;
+}

package/dist/script-components/components/condition/convertor/groovy.js

@@ -0,0 +1,131 @@
+import { RelationListValidate } from "../components/condition-relation/domain/relation-validate.js";
+class ConditionTitleConvertor {
+    relations;
+    constructor(relations){
+        this.relations = relations;
+    }
+    getTitle() {
+        const builder = this.getLabel(this.relations);
+        return builder.join(" ");
+    }
+    getLabel(relations) {
+        const builder = [];
+        for (const relation of relations){
+            const relationType = relation.type;
+            if ("group" !== relationType) {
+                if (relation.label) builder.push(relation.label.trim());
+            } else if (relation.children) {
+                const children = this.getLabel(relation.children);
+                builder.push('(');
+                builder.push(...children);
+                builder.push(')');
+            }
+        }
+        return builder;
+    }
+}
+class ConditionReturnConvertor {
+    relations;
+    groups;
+    constructor(state){
+        this.relations = state.relations;
+        this.groups = state.groups;
+    }
+    getReturn() {
+        const builder = this.getReturnExpression(this.relations);
+        return builder.join(" ");
+    }
+    getConditionGroup(id) {
+        for (let group of this.groups)if (group.id === id) return group;
+        return null;
+    }
+    getConditionGroupDataType(conditionGroup) {
+        if (conditionGroup.left) {
+            if ('variable' === conditionGroup.left.type) return conditionGroup.left.dataType;
+        }
+        if (conditionGroup.right) {
+            if ('variable' === conditionGroup.right.type) return conditionGroup.right.dataType;
+        }
+        return 'STRING';
+    }
+    getConditionExpression(condition, dataType) {
+        if ('variable' === condition.type) return condition.value;
+        if ('BOOLEAN' === dataType) return 'true' === condition.value;
+        if ('STRING' === dataType) return `'${condition.value}'`;
+        return `${condition.value}`;
+    }
+    getConditionTypeExpression(relationType) {
+        if ('equal' === relationType) return '==';
+        if ('not_equal' === relationType) return '!=';
+        if ('greater_equal' === relationType) return '>=';
+        if ('less_equal' === relationType) return '<=';
+        if ('greater_than' === relationType) return '>';
+        if ('less_than' === relationType) return '<';
+        return `${relationType}`;
+    }
+    getConditionGroupExpression(id) {
+        const conditionGroup = this.getConditionGroup(id);
+        if (conditionGroup) {
+            const dataType = this.getConditionGroupDataType(conditionGroup);
+            const left = conditionGroup.left;
+            const right = conditionGroup.right;
+            const type = conditionGroup.type;
+            if (left && right && type) {
+                const leftExpression = this.getConditionExpression(left, dataType);
+                const rightExpression = this.getConditionExpression(right, dataType);
+                const typeExpression = this.getConditionTypeExpression(type);
+                return leftExpression + typeExpression + rightExpression;
+            }
+        }
+        return '';
+    }
+    getReturnExpression(relations) {
+        const builder = [];
+        for (const relation of relations){
+            const relationType = relation.type;
+            if ("group" !== relationType) {
+                if ('and' === relationType) builder.push('&&');
+                if ('or' === relationType) builder.push('||');
+                if ('condition' === relationType) {
+                    if (relation.groupId) builder.push(this.getConditionGroupExpression(relation.groupId));
+                }
+            } else if (relation.children) {
+                builder.push('(');
+                const children = this.getReturnExpression(relation.children);
+                builder.push(...children);
+                builder.push(')');
+            }
+        }
+        return builder;
+    }
+}
+class ConditionGroovyConvertor {
+    state;
+    constructor(state){
+        this.state = state;
+    }
+    isError() {
+        const relationValidate = new RelationListValidate(this.state.relations);
+        return relationValidate.isError();
+    }
+    getMeta() {
+        return JSON.stringify(this.state);
+    }
+    getTitle() {
+        const titleConvertor = new ConditionTitleConvertor(this.state.relations);
+        return titleConvertor.getTitle();
+    }
+    getReturn() {
+        const returnConvertor = new ConditionReturnConvertor(this.state);
+        return returnConvertor.getReturn();
+    }
+    getScript() {
+        return `// @SCRIPT_TITLE ${this.getTitle()}
+        // @SCRIPT_META ${this.getMeta()}
+        def run(request){
+            return ${this.getReturn()};
+        }
+        `;
+    }
+}
+export { ConditionGroovyConvertor };

package/dist/script-components/components/condition/convertor/group.d.ts

@@ -0,0 +1,6 @@
+import { ConditionGroup } from "../typings";
+export declare class GroupConvertor {
+    private readonly group;
+    constructor(group: ConditionGroup);
+    getLabel(): string;
+}

package/dist/script-components/components/condition/convertor/group.js

@@ -0,0 +1,18 @@
+import { relationTypeOptions } from "../typings/index.js";
+class GroupConvertor {
+    group;
+    constructor(group){
+        this.group = group;
+    }
+    getLabel() {
+        const left = this.group.left;
+        const right = this.group.right;
+        const type = this.group.type;
+        if (left && right && type) {
+            const relation = relationTypeOptions.find((relationTypeOption)=>relationTypeOption.value === type);
+            return `${left.label} ${relation?.label} ${right.label}`;
+        }
+        return '未知';
+    }
+}
+export { GroupConvertor };

package/dist/script-components/components/condition/hooks/use-condition-context.d.ts

@@ -0,0 +1,10 @@
+import { ConditionContextScope } from "../context";
+import { ConditionViewProps } from "../typings";
+export declare const useConditionContext: () => {
+    state: import("../typings").ConditionState;
+    context: ConditionContextScope;
+};
+export declare const createConditionContext: (props: ConditionViewProps) => {
+    state: import("../typings").ConditionState;
+    context: ConditionContextScope;
+};

package/dist/script-components/components/condition/hooks/use-condition-context.js

@@ -0,0 +1,47 @@
+import react from "react";
+import { Presenter } from "../presenters/index.js";
+import { useDispatch, useSelector } from "react-redux";
+import { ConditionContext, ConditionContextScope } from "../context/index.js";
+import { updateState } from "../store.js";
+import { ConditionApiImpl } from "../models/index.js";
+import { useScriptMetaData } from "../../../hooks/use-script-meta-data.js";
+const useConditionContext = ()=>{
+    const context = react.useContext(ConditionContext);
+    const state = useSelector((state)=>state.condition);
+    if (!context) throw new Error("ConditionContext must be used within useContext");
+    return {
+        state,
+        context
+    };
+};
+const createConditionContext = (props)=>{
+    const ref = react.useRef(void 0);
+    const dispatch = useDispatch();
+    const state = useSelector((state)=>state.condition);
+    const initData = useScriptMetaData(props.script);
+    if (!ref.current) {
+        const presenter = new Presenter(state, (prevState)=>{
+            dispatch(updateState(prevState));
+            return prevState;
+        }, new ConditionApiImpl());
+        ref.current = new ConditionContextScope(presenter, props);
+        ref.current.initState({
+            ...initData,
+            variables: props.variables
+        });
+    }
+    react.useEffect(()=>{
+        ref.current?.syncState(state);
+    }, [
+        state
+    ]);
+    react.useEffect(()=>()=>{
+            ref.current?.clearState();
+            ref.current = void 0;
+        }, []);
+    return {
+        state,
+        context: ref.current
+    };
+};
+export { createConditionContext, useConditionContext };

package/dist/script-components/components/condition/hooks/use-condition-script-convertor.d.ts

@@ -0,0 +1,2 @@
+import { ConditionPanelProps } from "../typings";
+export declare const useConditionScriptConvertor: (props: ConditionPanelProps) => void;

package/dist/script-components/components/condition/hooks/use-condition-script-convertor.js

@@ -0,0 +1,14 @@
+import { useConditionContext } from "./use-condition-context.js";
+import { ConditionGroovyConvertor } from "../convertor/groovy.js";
+const useConditionScriptConvertor = (props)=>{
+    const { state } = useConditionContext();
+    if (state.relations) {
+        const scriptConvertor = new ConditionGroovyConvertor(state);
+        if (!scriptConvertor.isError()) {
+            const script = scriptConvertor.getScript();
+            props.onChange(script);
+            console.log("convert script", script);
+        }
+    }
+};
+export { useConditionScriptConvertor };

package/dist/script-components/components/condition/index.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { ConditionViewProps } from "./typings";
+export declare const ConditionView: React.FC<ConditionViewProps>;

package/dist/script-components/components/condition/index.js

@@ -0,0 +1,23 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { ConditionPanel } from "./components/condition-panel.js";
+import { Provider } from "react-redux";
+import { conditionStore } from "./store.js";
+import { createConditionContext } from "./hooks/use-condition-context.js";
+import { ConditionContext } from "./context/index.js";
+const ConditionViewScope = (props)=>{
+    const { context } = createConditionContext(props);
+    return /*#__PURE__*/ jsx(ConditionContext.Provider, {
+        value: context,
+        children: /*#__PURE__*/ jsx(ConditionPanel, {
+            ...props
+        })
+    });
+};
+const ConditionView = (props)=>/*#__PURE__*/ jsx(Provider, {
+        store: conditionStore,
+        children: /*#__PURE__*/ jsx(ConditionViewScope, {
+            ...props
+        })
+    });
+export { ConditionView };

package/dist/script-components/components/condition/models/index.d.ts

@@ -0,0 +1,3 @@
+import { ConditionApi } from "../typings";
+export declare class ConditionApiImpl implements ConditionApi {
+}

package/dist/script-components/components/condition/models/index.js

@@ -0,0 +1,3 @@
+class ConditionApiImpl {
+}
+export { ConditionApiImpl };

package/dist/script-components/components/condition/presenters/group-presenter.d.ts

@@ -0,0 +1,31 @@
+import { Presenter } from "./index";
+import { Condition, RelationType } from "../typings";
+/**
+ *  条件分组的Presenter对象
+ */
+export declare class ConditionGroupPresenter {
+    private readonly presenter;
+    constructor(presenter: Presenter);
+    /**
+     * 更新条件参数
+     * @param id
+     * @param location
+     * @param condition
+     */
+    updateCondition(id: string, location: 'left' | 'right', condition: Condition): void;
+    updateType(id: string, type: RelationType): void;
+    /**
+     *  添加条件
+     */
+    addCondition(): void;
+    /**
+     * 删除条件
+     * @param id
+     */
+    removeCondition(id: string): void;
+    /**
+     * 互换条件
+     * @param id
+     */
+    switchCondition(id: string): void;
+}

package/dist/script-components/components/condition/presenters/group-presenter.js

@@ -0,0 +1,80 @@
+import { IdUtils } from "../../../../utils/index.js";
+class ConditionGroupPresenter {
+    presenter;
+    constructor(presenter){
+        this.presenter = presenter;
+    }
+    updateCondition(id, location, condition) {
+        this.presenter.updateState((prevState)=>{
+            const groups = prevState.groups.map((group)=>{
+                if (group.id === id) return {
+                    ...group,
+                    [location]: condition
+                };
+                return group;
+            });
+            return {
+                ...prevState,
+                groups: groups
+            };
+        });
+    }
+    updateType(id, type) {
+        this.presenter.updateState((prevState)=>{
+            const groups = prevState.groups.map((group)=>{
+                if (group.id === id) return {
+                    ...group,
+                    type: type
+                };
+                return group;
+            });
+            return {
+                ...prevState,
+                groups: groups
+            };
+        });
+    }
+    addCondition() {
+        this.presenter.updateState((prevState)=>{
+            const groups = prevState.groups;
+            const group = {
+                id: IdUtils.generateId()
+            };
+            return {
+                ...prevState,
+                groups: [
+                    ...groups,
+                    group
+                ]
+            };
+        });
+    }
+    removeCondition(id) {
+        this.presenter.updateState((prevState)=>{
+            const groups = prevState.groups.filter((group)=>group.id !== id);
+            return {
+                ...prevState,
+                groups: groups
+            };
+        });
+    }
+    switchCondition(id) {
+        this.presenter.updateState((prevState)=>{
+            const target = prevState.groups.find((group)=>group.id === id);
+            const groups = prevState.groups;
+            const latest = [];
+            if (target) for (const group of groups)if (group.id === id) latest.push({
+                ...target,
+                left: target.right,
+                right: target.left
+            });
+            else latest.push(group);
+            else latest.push(...groups);
+            return {
+                ...prevState,
+                groups: latest
+            };
+        });
+    }
+}
+export { ConditionGroupPresenter };

package/dist/script-components/components/condition/presenters/index.d.ts

@@ -0,0 +1,21 @@
+import { Dispatch } from "@coding-flow/flow-core";
+import { ConditionApi, ConditionState } from "../typings";
+import { ConditionGroupPresenter } from "./group-presenter";
+import { ConditionRelationPresenter } from "./relation-presenter";
+/**
+ *  条件总控的Presenter
+ */
+export declare class Presenter {
+    private state;
+    private readonly dispatch;
+    private readonly api;
+    private readonly groupPresenter;
+    private readonly relationPresenter;
+    constructor(state: ConditionState, dispatch: Dispatch<ConditionState>, api: ConditionApi);
+    getConditionGroupPresenter(): ConditionGroupPresenter;
+    getConditionRelationPresenter(): ConditionRelationPresenter;
+    syncState(state: ConditionState): void;
+    initState(initData: any): void;
+    clearState(): void;
+    updateState(state: ((prevState: ConditionState) => ConditionState) | ConditionState): void;
+}

package/dist/script-components/components/condition/presenters/index.js

@@ -0,0 +1,36 @@
+import { initStateData } from "../typings/index.js";
+import { ConditionGroupPresenter } from "./group-presenter.js";
+import { ConditionRelationPresenter } from "./relation-presenter.js";
+class Presenter {
+    state;
+    dispatch;
+    api;
+    groupPresenter;
+    relationPresenter;
+    constructor(state, dispatch, api){
+        this.api = api;
+        this.dispatch = dispatch;
+        this.state = state;
+        this.groupPresenter = new ConditionGroupPresenter(this);
+        this.relationPresenter = new ConditionRelationPresenter(this);
+    }
+    getConditionGroupPresenter() {
+        return this.groupPresenter;
+    }
+    getConditionRelationPresenter() {
+        return this.relationPresenter;
+    }
+    syncState(state) {
+        this.state = state;
+    }
+    initState(initData) {
+        this.dispatch(initData);
+    }
+    clearState() {
+        this.dispatch(initStateData);
+    }
+    updateState(state) {
+        this.dispatch(state);
+    }
+}
+export { Presenter };

package/dist/script-components/components/condition/presenters/relation-presenter.d.ts

@@ -0,0 +1,13 @@
+import { Presenter } from "./index";
+import { LogicalRelation } from "../typings";
+/**
+ *  条件关系的Presenter对象
+ */
+export declare class ConditionRelationPresenter {
+    private readonly presenter;
+    constructor(presenter: Presenter);
+    removeRelation(id: string): void;
+    addRelation(target: LogicalRelation, sourceId?: string): void;
+    private removeRelations;
+    private appendRelations;
+}

package/dist/script-components/components/condition/presenters/relation-presenter.js

@@ -0,0 +1,65 @@
+class ConditionRelationPresenter {
+    presenter;
+    constructor(presenter){
+        this.presenter = presenter;
+    }
+    removeRelation(id) {
+        this.presenter.updateState((prevState)=>({
+                ...prevState,
+                relations: [
+                    ...this.removeRelations(id, prevState.relations)
+                ]
+            }));
+    }
+    addRelation(target, sourceId) {
+        this.presenter.updateState((prevState)=>{
+            if (sourceId) return {
+                ...prevState,
+                relations: [
+                    ...this.appendRelations(sourceId, prevState.relations, target)
+                ]
+            };
+            return {
+                ...prevState,
+                relations: [
+                    ...prevState.relations,
+                    target
+                ]
+            };
+        });
+    }
+    removeRelations(sourceId, relations) {
+        if (0 === relations.length) return [];
+        const list = [];
+        for (const relation of relations){
+            let current = {
+                ...relation
+            };
+            if (relation.children) current = {
+                ...relation,
+                children: this.removeRelations(sourceId, relation.children)
+            };
+            if (relation.id !== sourceId) list.push(current);
+        }
+        return list;
+    }
+    appendRelations(sourceId, relations, target) {
+        if (0 == relations.length) return [
+            target
+        ];
+        const list = [];
+        for (const relation of relations){
+            let current = {
+                ...relation
+            };
+            if (relation.children) current = {
+                ...relation,
+                children: this.appendRelations(sourceId, relation.children, target)
+            };
+            if ('action' !== current.type) list.push(current);
+            if (relation.id === sourceId) list.push(target);
+        }
+        return list;
+    }
+}
+export { ConditionRelationPresenter };

package/dist/script-components/components/condition/store.d.ts

@@ -0,0 +1,15 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { ConditionState } from "./typings";
+export type ConditionStoreAction = {
+    updateState: (state: ConditionState, action: PayloadAction<Partial<ConditionState> | ((prev: ConditionState) => Partial<ConditionState>)>) => void;
+};
+export declare const conditionSlice: import("@reduxjs/toolkit").Slice<ConditionState, ConditionStoreAction, "condition", "condition", {}>;
+export declare const updateState: import("@reduxjs/toolkit").ActionCreatorWithPayload<Partial<ConditionState> | ((prev: ConditionState) => Partial<ConditionState>), "condition/updateState">;
+export declare const conditionStore: import("@reduxjs/toolkit").EnhancedStore<{
+    condition: ConditionState;
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        condition: ConditionState;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export type ConditionReduxState = ReturnType<typeof conditionStore.getState>;