Cross-platform low-code development system and method supporting code export

Abstract

The invention belongs to the field of low-code platform development, and discloses a cross-platform low-code development system and method supporting code export. The method comprises the following steps: dividing a visual layout in a low-code platform into a central process region and R sub-process regions according to a preset rule; obtaining center structure data and sublevel structure data of the target project; obtaining a total logic complexity value of the project based on the central structure data and the sublevel structure data; obtaining an initial flow chart corresponding to the target project; inputting the central structure data, the sub-level structure data, the total logic complexity value and the initial flow chart into a pre-trained flow optimization model to obtain an optimized target flow chart; packaging a target sub-flow in the target flow chart to serve as a reusable plug-in of a cross-project flow; and the running efficiency of the developer project is effectively improved.

Description

Technical Field

[0001] The present invention belongs to the field of low-code platform development. More specifically, the present invention relates to a cross-platform low-code development system and method that supports code export. Background Art

[0002] The existing Chinese patent with the authorization announcement number CN115438050B discloses a hierarchical low-code development platform, including a module management unit, a menu item management unit, and a general query management unit. Among them: the module management unit is used to provide the design function of modules. Among them, the modules include function modules and form modules, and also provide the function of designing data structures for form modules, provide development controls, and design interfaces for form modules and function modules in a drag-and-drop manner based on the development controls. At the same time, it also supports the function of custom scripts; the menu item management unit is used to support the design of menu items and configure the basic information, data source SQL, menu item operation types, and their associated assemblies of menu items; the general query management unit is used to display the designed menu items and designed form modules through a record list. This platform can reduce the system complexity, meet the different needs of upper and lower levels, and achieve low coding.

[0003] The existing technology still has the following problems:

[0004] When the business processes or logics set by the user are too complex, the visual flowcharts tend to become large and difficult to manage; the project processes built by the user may be overly redundant, and there may be problems of piling up too many logic nodes in the layout interface, ultimately leading to the collapse of the project view and affecting the operation efficiency of the project.

[0005] In view of this, the present invention proposes a cross-platform low-code development system and method that supports code export to solve the above problems. Summary of the Invention

[0006] In order to overcome the above-mentioned defects of the prior art and to achieve the above object, the present invention provides the following technical solution: A cross-platform low-code development method that supports code export, including:

[0007] Dividing the visual layout in the low-code platform into a central process area and R sub-process areas according to preset rules;

[0008] Obtaining the central structure data and sub-structure data of the target project;

[0009] Based on the central structure data and sub-structure data, obtaining the total logic complexity value of the project;

[0010] Obtaining the initial flowchart corresponding to the target project;

[0011] Based on the central structure data, sub - structure data, total logical complexity value, and the initial flow chart, input them into a pre - trained process optimization model to obtain the optimized target flow chart;

[0012] Package the target sub - processes in the target flow chart as reusable plugins for cross - project processes;

[0013] Convert the project corresponding to the target flow chart and the reusable plugins into Dart source code files, and output the corresponding multi - terminal installation packages.

[0014] Furthermore, the method for obtaining the process optimization model includes:

[0015] Obtain z sets of process data sets. The process data set includes central structure data, sub - structure data, total logical complexity value, the initial flow chart, and the corresponding target flow chart. Use the process data set as a sample set, and divide the sample set into a training set and a test set. Build an RNN classifier. Use the central structure data, sub - structure data, total logical complexity value, and the initial flow chart in the training set as the input of the process optimization model, and use the corresponding target flow chart in the training set as the output. Iteratively train the classifier to obtain a preliminary optimization model. Use the test set to test the preliminary optimization model. If the accuracy of the preliminary optimization model meets the preset accuracy, then use the preliminary optimization model as the process optimization model. The preliminary optimization model is an RNN neural network model. z is a positive integer greater than 1.

[0016] Furthermore, the sub - process packaging method includes:

[0017] Step 1: Mark the reusable sub - process area in the editor, and mark the sub - process area as "plug - in process";

[0018] Step 2: The system packages the plug - in process into an independently managed plug - in and stores it in the team's public plug - in library. The plug - in includes the sub - structure data corresponding to the sub - process area and a plug - in description. The plug - in description includes the function description, usage scenario, and version information of the plug - in;

[0019] Step 3: When other projects in the team need to implement the same function, directly import the plug - in from the public plug - in library, and automatically generate a corresponding sub - process structure schematic diagram on the canvas;

[0020] Step 4: When team members collaborate on development, update the "plug - in" once, that is, synchronize it to each project using the sub - process, and finally integrate and export it for multi - terminal use.

[0021] Further, the central structure data is the quantified data in the central process area; the sub - structure data is the quantified data in the sub - process area; the quantified data includes the number of nodes, the number of connections, the nesting level, the usage frequency, and cross - area dependencies; the target project is the project constructed by the user.

[0022] The method for obtaining the total logic complexity value is as follows: By quantifying the number of nodes, the number of connections, the nesting level, the usage frequency, and cross - area dependencies, comprehensively evaluate the logic complexity of each area, and thus calculate the total logic complexity value of the entire project.

[0023] Further, the methods for obtaining the number of connections and cross - area dependencies include:

[0024] If both the start point and the end point of a connection are within the central process area, it is counted as the number of connections in the central process area.

[0025] If both the start point and the end point of a connection are within the same sub - process area, it is counted as the number of connections in the sub - process area.

[0026] If the start point and the end point of a connection are not within the same sub - process area and are not within the central process area, it is recorded as a cross - area dependency.

[0027] Further, the method for obtaining the nesting level includes:

[0028] When the low - code platform saves in the editor corresponding to the project, perform a DFS on the central process and the sub - processes respectively, and record the maximum level from the initial node corresponding to each process to the deepest branch; increment the count of the nesting level every time a node is passed through.

[0029] Further, the method for obtaining the number of nodes includes:

[0030] When the project is loaded, traverse all nodes once to detect the unique identifier and location of the nodes; if the location corresponding to a node is within the central process area, it is counted as the number of nodes in the central process area; if the location corresponding to a node is outside the central process area, it is counted as the number of nodes in the sub - process area.

[0031] Further, the initial flowchart is the project view constructed by the user on the cross - platform low - code development platform; the initial flowchart is obtained by taking a screenshot of the user's current window.

[0032] Further, the multi - platform installation packages include installation packages for Android, iOS, and Windows platforms; the Dart source code files are obtained through the Flutter command - line tool.

[0033] A cross-platform low-code development system supporting code export, implementing the cross-platform low-code development method supporting code export, includes:

[0034] A logical layering module that divides the visual layout in the low-code platform into a central process area and R sub-process areas according to preset rules;

[0035] A data acquisition module for acquiring the central structure data and sub-structure data of the target project;

[0036] A logical calculation module that obtains the total logical complexity value of the project based on the central structure data and sub-structure data;

[0037] A picture acquisition module for acquiring the initial flow chart corresponding to the target project;

[0038] A process optimization module that inputs the central structure data, sub-structure data, total logical complexity value, and initial flow chart into a pre-trained process optimization model to obtain the optimized target flow chart;

[0039] A team expansion module for packaging the target sub-process in the target flow chart as a reusable plug-in for cross-project processes;

[0040] A code output module for converting the project corresponding to the target flow chart and the reusable plug-in into Dart source code files and outputting corresponding multi-terminal installation packages.

[0041] The technical effects and advantages of the cross-platform low-code development system and method supporting code export of the present invention:

[0042] By acquiring the central structure data, sub-structure data, and total logical complexity value of the project, and combining the initial flow chart corresponding to the project, and inputting them into a pre-trained process optimization model to optimize the initial flow chart, by learning the mapping from the initial flow chart to the target flow chart in the training set, automatically performing optimization operations such as sub-process splitting and node folding on the process, reducing the operation burden of users in complex projects, and improving the quality of the automatically generated target flow chart, effectively improving the operation efficiency of the corresponding project.

[0043] Through the quantitative analysis of the number of nodes, number of connections, cross-region dependencies, nesting levels, and usage frequencies in the central process area and sub-process areas, this system intelligently calculates the complexity and optimizes the flow chart, reduces high-coupling areas, avoids the spread of the "tree branch" structure of the project view, and improves the readability of the flow chart; at the same time, the introduction of usage frequency enables nodes with high usage frequencies to be preferentially kept in the central process area, effectively improving the maintainability and optimization ability of the process.

[0044] With the support of the Flutter framework, this platform can automatically generate Dart source code and installation packages that are compatible with multiple platforms (such as Android, iOS, and Windows). By automating code generation, developers can quickly complete the deployment of cross-platform projects, reducing the workload of manual coding and packaging, and significantly improving the speed and quality of project launch. BRIEF DESCRIPTION OF THE DRAWINGS

[0045] Figure 1 Schematic diagram of a cross-platform low-code development system for supporting code export in Embodiment 1 of the present invention;

[0046] Figure 2 Flowchart of a cross-platform low-code development method for supporting code export in Embodiment 2 of the present invention;

[0047] Figure 3 Schematic diagram of the visual layout in Embodiment 1 of the present invention;

[0048] Figure 4 Schematic diagram of the widget panel in the low-code platform of Embodiment 1 of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0049] Next, the technical solutions in the embodiments of the present invention will be clearly and completely described in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all the embodiments. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the protection scope of the present invention.

[0050] Embodiment 1

[0051] Please refer to Figure 1 As shown, the cross-platform low-code development system for supporting code export in this embodiment includes: a logical layering module, a data acquisition module, a logical calculation module, an image acquisition module, a process optimization module, a team expansion module, and a code output module. Each module is connected by wire and / or wireless.

[0052] The logical layering module divides the visual layout in the low-code platform into a central process area and R sub-process areas according to preset rules; the preset rules are to set the main areas in the visual layout of the system in the low-code platform; the project process within the main area is the central process area; the project processes outside the main area are divided into R sub-process areas at a preset distance; R is a positive integer greater than 1.

[0053] Exemplarily, please refer to Figure 3As shown in the figure, the visual layout in the low-code platform is divided into a central process area and eight sub-process areas. There are four sub-process areas on each side of the central process area, and the spacing between adjacent sub-process areas is equal, all being 0.

[0054] It should be noted that regarding the "main area in the visual layout" as the central process area enables the subsequent system to quickly determine which nodes belong to the core business, and which are auxiliary logics or separable sub-processes; at the same time, when a user "draws" or "designates" a main area in the visual layout, it can also accurately express the business concerns.

[0055] A data acquisition module that acquires the central structure data and sub-structure data of the target project; the central structure data is the quantitative data in the central process area; the sub-structure data is the quantitative data in the sub-process area; the quantitative data includes the number of nodes, the number of connections, the nesting level, the usage frequency, and the cross-region dependency; the target project is a project constructed by the user.

[0056] The more the number of nodes, the more complex the logic; if the number of nodes in the central process area exceeds the preset number of nodes, it indicates that the current main process is too large, and subsequent maintenance and readability will significantly decline. It is necessary to split or streamline it again to prevent serious congestion on the canvas; if the number of nodes in the sub-process area is greater than or equal to the number of nodes in the central process area, it indicates that this sub-process may have exceeded the scale of the main process, weakening the original intention of the hierarchical design.

[0057] It should be noted that for the Flutter-based low-code development platform of the present invention, a node is represented as a logical function block, which corresponds to a Widget in Flutter.

[0058] Exemplarily, please refer to Figure 4 As shown in the figure, the low-code development platform includes a widget panel; the widgets include layout elements, basic elements, page elements, and form elements; the layout elements include left-right layout, up-down layout, container, flow layout, navigation switch, waterfall flow, list layout, grid layout, divider, vertical divider, card layout, spacing, stacking exchange, drag layout, flip card, expandable, table, carousel, and page view; each widget corresponds to a node.

[0059] The number of connections is the number of connections of the nodes in each area of the central process area and the sub-process areas; the more connections there are, the higher the coupling degree of the corresponding area, and the relatively higher the difficulty of modifying the area subsequently.

[0060] It should be noted that cross - region dependence refers to the number of connections across different regions (such as the number of connections between the central process region and the sub - process regions or between multiple sub - process regions); if the ratio of cross - region dependence to the total number of connections is greater than or equal to the preset ratio, it indicates that the user's division of the project process is not independent enough, and further optimization is required through the subsequent process optimization model to reduce the dependence between different regions and the scope of influence of subsequent fine - tuning; the total number of connections is the sum of the connections of nodes in each region of the central process region and the sub - process regions and the cross - region dependence.

[0061] The nesting level of the central process region represents the maximum depth of nested conditions, loops, and sub - process calls in the central process; the nesting level of the sub - process region represents the maximum depth of judgments, loops, and parallel structures within each sub - process; if the nesting level is too deep, the maintenance difficulty is high, and the canvas structure may spread in a "branch" - like manner, resulting in low readability; therefore, when calculating the logical complexity subsequently, taking the nesting level as a level weight index can significantly enhance the comprehensive evaluation accuracy of the overall process complexity; if the level weight is high, it indicates that the process has a deep - level nested structure and needs to be improved in the subsequent process optimization model to reduce the maintenance and modification costs.

[0062] The usage frequency is the number of times each node is triggered when the test project runs; by obtaining the number of times each node is triggered, it helps to improve the accuracy of the subsequent calculation of logical complexity; at the same time, taking the unique identifier of the node and the usage frequency of the node as the input of the subsequent process optimization model helps to improve the optimization ability of the model for the initial flowchart of the input; for example, nodes with high usage frequency often need to maintain maintainability and are thus classified in the central process.

[0063] The method for obtaining the number of nodes includes:

[0064] When the project is loaded, all nodes are traversed once to detect the unique identifier and position of the nodes; if the position corresponding to the node is within the main region, the number of nodes in the central process region is counted; if the position corresponding to the node is outside the main region, the number of nodes in the sub - process region is counted.

[0065] The method for obtaining the number of connections and the cross - region dependence includes:

[0066] If both the starting point and the ending point of the connection are within the central process region, the number of connections in the central process region is counted.

[0067] If both the starting point and the ending point of the connection are within the same sub - process region, the number of connections in the sub - process region is counted.

[0068] If the starting point and the ending point of the connection are not within the same sub - process region and are not within the central process region, it is recorded as a cross - region dependence.

[0069] The method for obtaining the nesting level includes:

[0070] When the low-code platform saves in the corresponding editor of the project, perform a round of DFS (Depth-First Search) on the central process and the sub-process respectively, and record the maximum level from the initial node corresponding to each process to the deepest branch; among them, the count of the nesting level can be increased once for each passed node.

[0071] The usage frequency is obtained by adding data points to the nodes; adding data points is a statistical code that records the number of occurrences of events when the project is running.

[0072] The logic calculation module obtains the total logic complexity value of the project based on the central structure data and the sub-structure data.

[0073] The method for obtaining the total logic complexity value includes:

[0074]

[0075] Among them, C is the total logic complexity value; R + 1 is the total number of the central process area and the sub-process area; r is the area number of the total number of the central process area and the sub-process area; N r is the number of nodes corresponding to the r-th area; M r is the number of connections corresponding to the r-th area; S r is the nesting level corresponding to the r-th area; q is the total number of cross-area dependencies of the project; Q is the total number of connections of the project; U is the average value of the usage frequencies of all nodes corresponding to the current area; α, β, λ and are the corresponding weight factors respectively.

[0076] The picture acquisition module is used to acquire the initial flow chart corresponding to the target project; the initial flow chart is the project view constructed by the user on the cross-platform low-code development platform.

[0077] The initial flow chart is obtained by taking a screenshot of the user's current window.

[0078] The process optimization module inputs the central structure data, the sub-structure data, the total logic complexity value and the initial flow chart into a pre-trained process optimization model to obtain the optimized target flow chart.

[0079] The method for obtaining the process optimization model includes:

[0080] Obtain z sets of process data sets. The process data sets include central structure data, sub - level structure data, total logical complexity values, initial flowcharts, and corresponding target flowcharts. Use the process data sets as sample sets, and split the sample sets into training sets and test sets. Build an RNN classifier. Use the central structure data, sub - level structure data, total logical complexity values, and initial flowcharts in the training set as inputs to the process optimization model, and use the corresponding target flowcharts in the training set as outputs. Iteratively train the classifier to obtain a preliminary optimization model. Use the test set to test the preliminary optimization model. If the accuracy of the preliminary optimization model meets the preset accuracy, then use the preliminary optimization model as the process optimization model. The preliminary optimization model is an RNN neural network model. z is a positive integer greater than 1.

[0081] It should be noted that the corresponding target flowcharts in the process data sets are constructed by those skilled in the art after optimizing the initial flowcharts. The optimization operations include sub - process - ing and node folding. The purpose is to reduce the density of single - process nodes and connections, and avoid excessive congestion and overly high complexity of the canvas. Sub - process - ing refers to splitting large - scale and complex process areas into smaller and more manageable sub - modules. Node folding is to merge multiple closely - connected nodes into a higher - level logical block. The optimization operations help reduce the nesting levels in the flowchart and simplify the connection relationships, thereby improving the readability and maintainability of the flowchart.

[0082] By constructing the target flowcharts, the pre - trained process optimization model can learn the mapping relationship from the initial complex flowcharts to the simplified and optimized flowcharts. This not only helps the system automatically optimize the business processes in the low - code platform, but also provides solid data support for subsequent process optimization. The use of the training set and the test set ensures the generalization ability of the optimization model, so as to adapt to the flowchart optimization requirements of different project complexities.

[0083] The team expansion module is used to package the target sub - processes in the target flowchart as reusable plugins for cross - project processes.

[0084] When multiple projects need to share some common process segments or business logics, the previously split sub - processes can be packaged as "reusable plugins" to improve team collaboration efficiency and reduce the cost of repeated development.

[0085] The method for packaging the sub - processes includes:

[0086] Step 1: Mark the sub - process area to be reused in the editor, and mark the sub - process area as a "plugin - enabled process". The marking of the plugin - enabled process enables this sub - process area to be reused as an independent module in different projects, without depending on other process parts of the current project.

[0087] Step 2: The system packages the plug-in process into an independently manageable plug-in and stores it in the team's public plug-in library; the plug-in includes sub-structure data corresponding to the sub-process area and a plug-in description; the plug-in description includes the function description, usage scenario, and version information of the plug-in, facilitating team members to understand the role of the plug-in.

[0088] Step 3: When other projects in the team need to implement the same function, directly import the plug-in from the public plug-in library, thereby automatically generating a corresponding sub-process structure schematic diagram on the canvas.

[0089] It should be noted that since the target sub-process in the target flow chart is used as the plug-in, the plug-in at this time corresponds to the optimized sub-process area and has modularity and high maintainability.

[0090] Step 4: When team members collaborate on development, update the "plug-in" once, that is, synchronize it to each project using this sub-process, and finally integrate and export it for multi-terminal use.

[0091] It should be noted that the updated plug-in will be automatically synchronized to all projects using the plug-in, avoiding the repetitive labor of separately modifying and updating the same function for each project.

[0092] The code output module converts the project corresponding to the target flow chart and the reusable plug-in into Dart source code files and outputs corresponding multi-terminal installation packages.

[0093] With the support of the Flutter cross-platform framework, the optimized process can automatically generate Dart source code and installation packages adapted to multiple platforms, including Android, iOS, and Windows, etc., ensuring the cross-platform compatibility and scalability of the projects built by users; at the same time, the function of automatically generating code and installation packages reduces the manual operations of developer users and improves the project go-live speed.

[0094] It should be noted that Flutter is an open-source UI toolkit developed by Google and is designed specifically for building high-performance and high-fidelity cross-platform applications; Flutter does not rely on platform-native controls but directly draws the UI onto the canvas through its own graphics engine (Skia); this makes the UI performance on platforms such as Android, iOS, and Windows exactly the same, effectively avoiding the component adaptation problems of traditional cross-platform frameworks.

[0095] It should be noted that Dart is an object-oriented programming language developed by Google and is also the official development language of Flutter. Users only need to write Dart code, and Flutter automatically handles multi-platform adaptation issues. The Dart source code is the "language carrier" of the Flutter cross-platform framework, and the Flutter cross-platform framework is the "functional framework" of the Dart source code.

[0096] The multi-terminal installation packages include installation packages for platforms such as Android, iOS, and Windows.

[0097] The Dart source code files are obtained through the Flutter command-line tool.

[0098] Embodiment 2

[0099] Please refer to Figure 2 As shown, this embodiment provides a cross-platform low-code development method that supports code export, including:

[0100] Dividing the visual layout in the low-code platform into a central process area and R sub-process areas according to preset rules;

[0101] Obtaining the central structure data and sub-structure data of the target project;

[0102] Based on the central structure data and sub-structure data, obtaining the total logical complexity value of the project;

[0103] Obtaining the initial flowchart corresponding to the target project;

[0104] Based on the central structure data, sub-structure data, total logical complexity value, and initial flowchart, inputting them into a pre-trained process optimization model to obtain the optimized target flowchart;

[0105] Packaging the target sub-processes in the target flowchart as reusable plugins for cross-project processes;

[0106] Converting the project corresponding to the target flowchart and the reusable plugins into Dart source code files and outputting the corresponding multi-terminal installation packages.

[0107] Embodiment 3

[0108] In order to ensure that users can maintain high efficiency and high maintainability when building large projects for module management and reuse, the present invention also provides a multi-level sub-process division system. It can not only split complex project processes into multiple smaller and more manageable and reusable modules, but also ensure the independence and maintainability of each sub-process, thus avoiding the maintenance difficulty caused by overly complex structures. The detailed operation steps of the multi-level sub-process division are as follows:

[0109] Step 1: When calculating the total logical complexity value, record the logical complexity value corresponding to each area.

[0110] Step 2: If the logical complexity value of the current area is greater than the preset complexity threshold, further split it into two sub - process areas, marked as n - level sub - areas; the initial value of n is 1.

[0111] Step 3: If the logical complexity value of the n - level sub - area is still greater than the preset complexity threshold, further split it into two sub - process areas, marked as (n + 1) - level sub - areas.

[0112] Step 4: Repeat Step 3 until the logical complexity value of the newly split sub - area is less than or equal to the preset complexity threshold, and record all the split sub - areas, so that when packing the target sub - process in the target flow chart later, it is more intuitive and concise.

[0113] Through this multi - level sub - process division method, the system can effectively reduce the process complexity while maintaining high efficiency and modularity, ensuring that users can quickly identify and maintain each independent sub - process area when managing complex projects, improving the accuracy when reusing sub - process areas, and further improving the operation efficiency of the user team when building the overall project.

[0114] The above - described embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them; although the present application has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that: they can modify the technical solutions recorded in the foregoing embodiments, or perform equivalent replacements for some of the technical features; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present application, and should all be included in the protection scope of the present application.

Claims

1. A cross-platform low-code development method that supports code export, characterized by: include: Divide the visual layout in the low-code platform into a central process area and R sub-process areas according to preset rules; Obtain the central structure data and sub-structure data of the target project; Based on the central structure data and the sub-structure data, the total logic complexity value of the project is obtained; Get the initial flow chart corresponding to the target project; Based on the central structure data, the sub-level structure data, the total logic complexity value and the initial flowchart, the data are input into the pre-trained process optimization model to obtain the optimized target flowchart; Package the target sub-process in the target flowchart as a reusable plug-in for cross-project processes; Convert the projects and reusable plug-ins corresponding to the target flowchart into Dart source code files, and output the corresponding multi-terminal installation packages.

2. The cross-platform low-code development method supporting code export according to claim 1, characterized in that: The method for obtaining the process optimization model includes: Obtain z groups of process data sets, the process data sets include central structure data, sub-level structure data, total logic complexity value, initial flowchart and corresponding target flowchart; take the process data set as a sample set, and divide the sample set into a training set and a test set; construct an RNN classifier, take the central structure data, sub-level structure data, total logic complexity value and initial flowchart in the training set as input of the process optimization model, take the corresponding target flowchart in the training set as output, iteratively train the classifier to obtain a preliminary optimization model; use the test set to test the preliminary optimization model, if the accuracy of the preliminary optimization model meets the preset accuracy, then use the preliminary optimization model as the process optimization model; the preliminary optimization model is an RNN neural network model; z is a positive integer greater than 1.

3. The cross-platform low-code development method supporting code export according to claim 1, characterized in that: The sub-process packaging method comprises: Step 1: Mark the reused sub-process area in the editor, and mark the sub-process area as a plug-in process; Step 2: The system packages the plug-in process into an independently managed plug-in and stores it in the team's public plug-in library; the plug-in includes sub-level structure data corresponding to the sub-process area and a plug-in description; the plug-in description includes a functional description, usage scenario, and version information of the plug-in; Step 3: When other projects in the team need to implement the same function, they can directly import the plug-in from the public plug-in library and automatically generate the corresponding sub-process structure diagram on the canvas; Step 4: When team members collaborate on development, the plug-in is updated once, that is, synchronized to each project that uses the sub-process, and finally integrated and exported to multiple terminals for use.

4. The cross-platform low-code development method supporting code export according to claim 1, characterized in that: The central structure data is the quantitative data in the central process area; the sub-level structure data is the quantitative data in the sub-process area; the quantitative data includes the number of nodes, the number of links, the nesting level, the frequency of use and the cross-area dependency; the target project is the project constructed by the user; The method for obtaining the total logic complexity value is: by quantifying the number of nodes, the number of connections, the nesting level, the frequency of use and cross-region dependencies, comprehensively evaluating the logic complexity of each area, and thus calculating the total logic complexity value of the entire project.

5. The cross-platform low-code development method supporting code export according to claim 4, characterized in that: The method for obtaining the number of connections and the cross-zone dependency includes: If the starting point and end point of a connection line are both within the central flow area, then it is counted into the number of connections in the central flow area; If the starting point and end point of a line are both in the same sub-process area, then it is counted in the number of lines in the sub-process area; If the starting point and end point of the connection are not in the same sub-process area and are not in the central process area, it is recorded as a cross-area dependency.

6. The cross-platform low-code development method supporting code export according to claim 4, characterized in that: The method for obtaining the nested level includes: When the editor corresponding to the project is saved, the low-code platform performs a round of DFS on the central process and sub-process, recording the maximum level from the initial node corresponding to each process to the deepest branch; the nested level count is increased once each node passed.

7. The cross-platform low-code development method supporting code export according to claim 4, characterized in that: The method for obtaining the number of nodes includes: When the project is loaded, all nodes are traversed once to detect the unique identification and position of the nodes; if the position corresponding to the node is within the central process area, it is counted into the number of nodes in the central process area; if the position corresponding to the node is outside the central process area, it is counted into the number of nodes in the sub-process area.

8. The cross-platform low-code development method supporting code export according to claim 1, characterized in that: The initial flowchart is a project view built by the user on the cross-platform low-code development platform; the initial flowchart is obtained by taking a screenshot of the user's current window.

9. The cross-platform low-code development method supporting code export according to claim 1, characterized in that: The multi-terminal installation package includes installation packages for Android, iOS, and Windows platforms; the Dart source code file is obtained through the Flutter command line tool.

10. A cross-platform low-code development system supporting code export, implementing the cross-platform low-code development method supporting code export as described in any one of claims 1 to 9, characterized in that: include: The logical layering module divides the visual layout in the low-code platform into a central process area and R sub-process areas according to preset rules; A data acquisition module is used to acquire the central structure data and sub-structure data of the target project; The logic calculation module obtains the total logic complexity value of the project based on the central structure data and the sub-level structure data; Image acquisition module, used to obtain the initial flow chart corresponding to the target project; The process optimization module inputs the central structure data, the sub-level structure data, the total logic complexity value and the initial flow chart into the pre-trained process optimization model to obtain the optimized target flow chart; Team extension module, used to package the target sub-processes in the target flow chart as a reusable plug-in for cross-project processes; The code output module is used to convert the projects and reusable plug-ins corresponding to the target flowchart into Dart source code files and output the corresponding multi-terminal installation packages.

Images