Method for realizing coexistence of multiple frameworks of applet based on cross-end framework

Abstract

The invention belongs to the technical field of computers, and particularly relates to an applet multi-framework coexistence implementation method based on a cross-end framework, projects using different technical frameworks are compiled into respective products: projectA is developed by using a technical framework A, a compiled product file is distA, and then the distA is integrated into pageA.js, pageA.json, pageA.wxml and page.wxss; the projectB is developed by using a technical framework B, a compiled product file is distB, and then the distB is integrated into pageB.js, pageB.json, pageB.wxml and page.wxss; the projectC is developed by using a technical framework C, a compiled product file is distC, and then the distC is integrated into pageC.js, pageC.json, pageC.wxml and page.wxss; according to the invention, a plurality of technical frameworks are used for development; a plurality of frameworks can coexist and can be independently and randomly combined for deployment and release; and flexibility and expandability: different technical frameworks are used for development, and the most suitable framework can be selected according to project requirements. The method allows a development team to use different frameworks in the same applet at the same time, thereby providing greater flexibility and expandability.

Description

Technical Field

[0001] The present invention belongs to the field of computer technology, and particularly relates to a method for implementing coexistence of multiple frameworks of mini-programs based on a cross-terminal framework. Background Art

[0002] Currently, WeChat mini-programs can only be developed using one technical framework.

[0003] However, the existing technologies have the following defects:

[0004] A. It is impossible to develop using multiple technical frameworks simultaneously.

[0005] B. Program developers cannot gradually upgrade the architecture. Summary of the Invention

[0006] In view of this, embodiments of the present invention hope to provide a method for implementing coexistence of multiple frameworks of mini-programs based on a cross-terminal framework to solve or alleviate the technical problems existing in the prior art and provide at least one beneficial option for the above technical problems.

[0007] To achieve the above object, the present invention provides the following technical solutions:

[0008] A method for implementing coexistence of multiple frameworks of mini-programs based on a cross-terminal framework, the method comprising the following steps:

[0009] S1. Compile projects using different technical frameworks into their respective products:

[0010] ProjectA is developed using technical framework A, and the product file after compilation is distA, which is then integrated into pageA.js, pageA.json, pageA.wxml, and page.wxss;

[0011] ProjectB is developed using technical framework B, and the product file after compilation is distB, which is then integrated into pageB.js, pageB.json, pageB.wxml, and page.wxss;

[0012] ProjectC is developed using technical framework C, and the product file after compilation is distC, which is then integrated into pageC.js, pageC.json, pageC.wxml, and page.wxss;

[0013] S2. Deploy and release the products by randomly combining them:

[0014] Arbitrarily combine any number of the three products distA, distB, and distC of S1, merge them into the same product dist, and release the mini-program, or release the mini-program using distA / distB / distC alone;

[0015] In the mini-program miniapp1 after merging distA + distB + distC, pageA, pageB, and pageC can jump to each other;

[0016] In the mini-program miniapp2 after merging distA + distB, pageA and pageB can jump to each other;

[0017] In the mini-program miniapp3 after merging distA + distC, pageA and pageC can jump to each other;

[0018] In the mini-program miniapp4 after merging distB + distC, pageB and pageC can jump to each other;

[0019] Release the mini-program miniapp5 using distA alone.

[0020] As a further solution of the present invention: The method further includes the following steps:

[0021] Step 1: Obtain each business module associated with the mini-program to be developed;

[0022] Step 2: Provide the Taro basic template and the native common basic module;

[0023] Step 3: Based on the Taro basic template, create at least one Taro source code module; wherein, each Taro source code module corresponds to one of the business modules;

[0024] Step 4: Integrate and compile the Taro source code module to obtain a compilation product;

[0025] Step 5: Integrate the compilation product and the native common basic module to generate and release the first target mini-program;

[0026] Step 6: Develop and implement the front-end pages and components through a general front-end programming language or a general DSL;

[0027] Step 7: Finally, put the development result of Step 6 into different containers and the number of containers is two or more; Step 8: Compile, build, or package the development result of Step 6 with the capabilities of two or more different frameworks;

[0028] Step 9: Put the compilation result of Step 8 into the containers described in Step 7.

[0029] As a further solution of the present invention: the general front-end programming languages in step six include but are not limited to Javascript, HTML, and CSS;

[0030] The general DSLs include but are not limited to React and extended DSLs based on React features;

[0031] General DSLs include but are not limited to Vue and extended DSLs based on Vue features;

[0032] General DSLs include but are not limited to mini-program syntax and extended DSLs based on the syntax features of mini-program syntax.

[0033] As a further solution of the present invention: the containers in step seven include but are not limited to Web containers, H5 containers, ReactNative containers, Weex containers, Fultter containers, Electron containers, Tauri containers, or mainstream browsers on the market.

[0034] As a further solution of the present invention: the frameworks in step eight include but are not limited to cross-terminal frameworks developed according to React technical standards, including but not limited to Taro and Rax frameworks;

[0035] Cross-terminal frameworks developed according to Vue technical standards, including but not limited to Chameleon, uni-app, mpvue, and WePY frameworks;

[0036] Cross-terminal frameworks for Native oriented by Web technical standards, including but not limited to ReactNative and Weex frameworks;

[0037] Cross-terminal frameworks for Native oriented by other technical standards, including but not limited to Flutter.

[0038] As a further solution of the present invention: between step four and step five, there is also a step of obtaining the storage repositories of the Taro source code modules corresponding to each business module;

[0039] According to the storage repositories of the Taro source code modules, generate the subpackage path information corresponding to each Taro source code module;

[0040] Step five also includes:

[0041] Add the subpackage path information corresponding to each Taro source code module to the project configuration of the first target mini-program.

[0042] As a further solution of the present invention: step four includes: identifying the placeholders in each Taro source code module;

[0043] Determine the root path in the Taro source code module for referencing the files in the to-be-developed applet according to the placeholder.

[0044] After compiling each Taro source code module according to the placeholder and the root path, obtain the relative path for referencing the file; the compilation product includes the relative path.

[0045] As a further solution of the present invention: Step four further includes: obtaining the subpackage structure configuration information corresponding to each Taro source code module;

[0046] Generate the common code extraction configuration information and the subpackage common file path of the preset packaging tool according to the subpackage structure configuration information.

[0047] Package the subpackage common files from the third-party modules depended on by the Taro source code module according to the common code extraction configuration information and the subpackage common file path.

[0048] As a further solution of the present invention: Step four includes: obtaining the release repository corresponding to the first target applet;

[0049] Obtain the first subrepository corresponding to each Taro source code module and the second subrepository corresponding to the Taro basic template;

[0050] Establish the parent-child repository association relationship between the first subrepository and the release repository, and between the second subrepository and the release repository respectively;

[0051] Step five includes:

[0052] Generate the first target applet according to the parent-child repository association relationship.

[0053] As a further solution of the present invention: The method further includes the step of: obtaining the Taro module configuration information stored on the server side;

[0054] Obtain the corresponding target Taro source code module according to the Taro module configuration information;

[0055] Establish a new parent-child repository association relationship according to the target Taro source code module;

[0056] Generate the second target applet according to the new parent-child repository association relationship.

[0057] Due to the above technical solutions adopted in the embodiments of the present invention, it has the following advantages:

[0058] First, develop using multiple technical frameworks;

[0059] II. Multiple frameworks can coexist, be independent, and be deployed and released in any combination.

[0060] III. Flexibility and scalability: When developing using different technology frameworks, the most suitable framework can be selected according to project requirements. This approach allows the development team to use different frameworks simultaneously in the same mini-program, thus providing greater flexibility and scalability.

[0061] IV. Reusing existing code and ecosystem: By integrating the products of each technology framework, existing code and ecosystem can be effectively reused. Developers can utilize the rich functions and tools provided by each framework to speed up the development process and reduce repetitive labor.

[0062] V. Mutual navigation between pages: The combined deployment of products from different frameworks allows mutual navigation between pages. For example, in mini-program miniapp1, pageA, pageB, and pageC can navigate to each other, and this flexible combination can meet different business requirements.

[0063] VI. Independent modular development: When developing using multiple frameworks, a modular approach can be adopted to design and develop different pages and functional modules. This enables different team members to develop different modules in parallel and perform testing and integration independently, improving development efficiency.

[0064] VII. Reducing technology stack conflicts: For different requirements and business scenarios, different technology frameworks can be selected to solve problems. This method can reduce development difficulties and debugging issues caused by technology stack conflicts and improve development efficiency.

[0065] The above summary is only for the purpose of the specification and is not intended to limit in any way. In addition to the illustrative aspects, embodiments, and features described above, further aspects, embodiments, and features of the present invention will be readily apparent by referring to the accompanying drawings and the following detailed description. BRIEF DESCRIPTION OF THE DRAWINGS

[0066] To more clearly illustrate the technical solutions in the embodiments of the present application or in the prior art, the following will briefly introduce the drawings required for use in the description of the embodiments or the prior art. Obviously, the drawings in the following description are only some embodiments of the present application, and those of ordinary skill in the art can obtain other drawings without creative efforts based on these drawings.

[0067] Figure 1 is the flow of an implementation method for a mini-program with multiple frameworks coexisting based on a cross-terminal framework of the present invention Figure 1 .

[0068] Figure 2 The process of an implementation method for multiple-frame coexistence of mini-programs based on a cross-terminal framework in the present invention Figure 2 . Specific implementation manners

[0069] In the following text, only some exemplary embodiments are simply described. As those skilled in the art can recognize, the described embodiments can be modified in various different ways without departing from the spirit or scope of the present invention. Therefore, the drawings and the description are considered to be exemplary in nature rather than restrictive.

[0070] It should be noted that terms such as "first", "second", "symmetric", "array", etc. are only used for the purpose of distinguishing descriptions and position descriptions, and cannot be understood as indicating or implying relative importance or implicitly indicating the quantity of the indicated technical features. Thus, features defined with "first", "symmetric", etc. can explicitly or implicitly include one or more of such features; similarly, when there is no numerical limitation on certain features in the form of "two", "three", etc., it should be noted that such features also belong to explicitly or implicitly including one or more feature quantities.

[0071] As Figure 1 shown, an implementation method for multiple-frame coexistence of mini-programs based on a cross-terminal framework in the present invention includes the following steps:

[0072] S1. Compile projects using different technical frameworks into their respective products:

[0073] ProjectA is developed using technical framework A, and the product file after compilation is distA, which is then integrated into pageA.js, pageA.json, pageA.wxml, page.wxss;

[0074] ProjectB is developed using technical framework B, and the product file after compilation is distB, which is then integrated into pageB.js, pageB.json, pageB.wxml, page.wxss;

[0075] ProjectC is developed using technical framework C, and the product file after compilation is distC, which is then integrated into pageC.js, pageC.json, pageC.wxml, page.wxss;

[0076] S2. Randomly combine the products for deployment and release:

[0077] Arbitrarily combine any number of the three products distA, distB, and distC of S1, merge them into the same product dist, and release the mini-program, or release the mini-program separately using distA / distB / distC;

[0078] In the mini-program miniapp1 after merging distA+distB+distC, pageA, pageB, and pageC can jump to each other;

[0079] In the mini-program miniapp2 after merging distA+distB, pageA and pageB can jump to each other;

[0080] In the mini-program miniapp3 after merging distA+distC, pageA and pageC can jump to each other;

[0081] In the mini-program miniapp4 after merging distB+distC, pageB and pageC can jump to each other;

[0082] Release the mini-program miniapp5 using distA alone.

[0083] Multi-framework project compilation: Develop projects separately using different technical frameworks (such as Framework A, Framework B, and Framework C), and compile each project into the corresponding product (such as distA, distB, distC). Each product includes the JavaScript file of the page (such as pageA.js), the configuration file of the page (such as pageA.json), the structure file of the page (such as pageA.wxml), and the style file of the page (such as pageA.wxss).

[0084] Deployment and release combination: Flexibly combine the above products to deploy and release the mini-program. You can choose to merge any number of products (such as distA, distB, distC) into the same product (such as dist) to release the mini-program, or release the mini-program separately using a certain product (such as distA / distB / distC).

[0085] Page jump relationship: Determine the jump relationship between pages in the mini-program according to the combined product. For example, in the mini-program miniapp1 after merging distA and distB, pageA, pageB, and pageC can jump to each other. Similarly, the mini-programs under other combination schemes (such as miniapp2, miniapp3, miniapp4) also have different jump relationships between pages.

[0086] Cross - platform framework support: This method requires the use of a technical framework that supports cross - platform development so that projects with different technical frameworks can be compiled into products respectively and flexibly combined for deployment. Common cross - platform frameworks include Taro, Uni - App, etc.

[0087] Multi - framework integrated compilation: For different technical frameworks (such as Framework A, Framework B, Framework C), project development is required and they are respectively compiled into corresponding products (such as distA, distB, distC). In this process, it is necessary to ensure that the compiled products of different frameworks can be correctly integrated into the page structure and styles of the mini - program.

[0088] Flexible deployment and release: This method requires the ability to flexibly combine products for the deployment and release of the mini - program. This may involve custom packaging tools or scripts to achieve the combination of any number of products and determine the jump relationships between pages in the mini - program according to the combination.

[0089] Page jump relationship management: For mini - programs under different combination schemes, it is necessary to accurately define the jump relationships between pages. This may require managing the jump logic between different pages through configuration files or other means to ensure that the combined mini - program can run correctly.

[0090] Modular development and integration: To ensure the independence and reusability of each module, a modular development approach needs to be adopted and ensure that each product can be effectively integrated and integrated to avoid conflicts and compatibility issues.

[0091] As Figure 2 shown, an implementation method for co - existence of multiple frameworks in a mini - program based on a cross - platform framework according to the present invention further includes the following steps:

[0092] Step 1: Obtain each business module associated with the mini - program to be developed;

[0093] Step 2: Provide a Taro basic template and native common basic modules;

[0094] Step 3: Based on the Taro basic template, create at least one Taro source code module; where each Taro source code module corresponds to one of the business modules;

[0095] Step 4: Integrate and compile the Taro source code module to obtain a compiled product;

[0096] Including identifying placeholders in each Taro source code module;

[0097] According to the placeholder, determine the root path in the Taro source code module for referencing files in the mini - program to be developed;

[0098] After compiling each of the Taro source code modules according to the placeholder and the root path, a relative path for referencing the file is obtained; the compilation product includes the relative path;

[0099] It also includes obtaining the subpackage structure configuration information corresponding to each of the Taro source code modules;

[0100] According to the subpackage structure configuration information, generate the public code extraction configuration information and the subpackage public file path of the preset packaging tool;

[0101] According to the public code extraction configuration information and the subpackage public file path, package the subpackage public files from the third-party modules on which the Taro source code modules depend;

[0102] Obtain the release repository corresponding to the first target mini-program;

[0103] Obtain the first sub-repository corresponding to each of the Taro source code modules and the second sub-repository corresponding to the Taro basic template;

[0104] Establish a parent-child repository association relationship between the first sub-repository and the release repository, and between the second sub-repository and the release repository respectively;

[0105] Between step four and step five, it also includes the step of obtaining the storage repository of the Taro source code module corresponding to each business module;

[0106] According to the storage repository of each of the Taro source code modules, generate the subpackage path information corresponding to each of the Taro source code modules;

[0107] Step five, integrate the compilation product and the native public basic module to generate and release the first target mini-program. According to the parent-child repository association relationship, generate the first target mini-program, and add the subpackage path information corresponding to each of the Taro source code modules to the project configuration corresponding to the first target mini-program;

[0108] Step six, develop and implement the front-end pages and components through a general front-end programming language or a general DSL. The general front-end programming language includes but is not limited to Javascript, HTML, CSS;

[0109] The general DSL includes but is not limited to React and the extended DSL based on the characteristics of React;

[0110] The general DSL includes but is not limited to Vue and the extended DSL based on the characteristics of Vue;

[0111] The general DSL includes, but is not limited to, the applet syntax and the extended DSL based on the syntax features of the applet syntax;

[0112] Step 7: Finally deploy the development result of Step 6 to different containers, and the number of containers is two or more. The containers include, but are not limited to, Web containers, H5 containers, ReactNative containers, Weex containers, Fultter containers, Electron containers, Tauri containers, or mainstream browsers on the market;

[0113] Step 8: Compile, build, or package the development result of Step 6 with the capabilities of two or more different frameworks. The frameworks include, but are not limited to, cross-terminal frameworks developed according to the React technology standard, which include, but are not limited to, the Taro and Rax frameworks;

[0114] Cross-terminal frameworks developed according to the Vue technology standard, which include, but are not limited to, the Chameleon, uni-app, mpvue, and WePY frameworks;

[0115] Cross-three-terminal frameworks for Native based on the Web technology standard, which include, but are not limited to, the ReactNative and Weex frameworks;

[0116] Cross-terminal frameworks for Native based on other technology standards, which include, but are not limited to, Flutter;

[0117] Step 9: Deploy the compilation result of Step 8 to the containers described in Step 7.

[0118] The method further includes the steps of: obtaining the Taro module configuration information stored on the server side;

[0119] According to the Taro module configuration information, obtain the corresponding target Taro source code module;

[0120] According to the target Taro source code module, establish a new parent-child repository association relationship;

[0121] According to the new parent-child repository association relationship, generate the second target applet.

[0122] Obtain each business module associated with the applet to be developed.

[0123] Provide the Taro basic template and the native common basic module.

[0124] Based on the Taro basic template, create at least one Taro source code module, and each Taro source code module corresponds to a business module.

[0125] Integrate and compile the Taro source code modules to generate compilation products. During this process, identify the placeholders in each Taro source code module and determine the root path for referencing files in the mini-program to be developed. Based on the placeholders and the root path, compile each Taro source code module to obtain the relative paths for referencing files. The compilation products include the relative paths. At the same time, obtain the subpackage structure configuration information corresponding to each Taro source code module, generate the public code extraction configuration information and subpackage public file paths for the preset packaging tool, and package the subpackage public files from the third-party modules.

[0126] Obtain the release repository corresponding to the first target mini-program, as well as the first sub-repositories corresponding to each Taro source code module and the second sub-repository corresponding to the Taro basic template. Establish a parent-child repository association relationship.

[0127] Between Step 4 and Step 5, obtain the storage repositories of the Taro source code modules corresponding to each business module and generate the subpackage path information corresponding to each Taro source code module.

[0128] Integrate the compilation products and the native public basic modules to generate and release the first target mini-program. According to the parent-child repository association relationship, add the subpackage path information corresponding to the Taro source code module to the project configuration of the first target mini-program.

[0129] Use a general front-end programming language or a general DSL to develop and implement the front-end pages and components. JavaScript, HTML, CSS, React, Vue, mini-program syntax, etc. can be used. Put the development results into different containers, such as Web containers, H5 containers, ReactNative containers, Weex containers, Flutter containers, Electron containers, Tauri containers, or mainstream browsers on the market.

[0130] Compile, build, or package the development results in Step 8 with the help of different framework capabilities. Cross-end frameworks developed according to the React technology standard (such as Taro, Rax), cross-end frameworks developed according to the Vue technology standard (such as Chameleon, uni-app, mpvue, WePY), cross-three-end frameworks oriented to Native according to the Web technology standard (such as ReactNative, Weex), or other cross-end frameworks oriented to Native (such as Flutter) can be used.

[0131] Put the compilation results in Step 8 into the containers described in Step 7.

[0132] In addition, the method further includes obtaining the Taro module configuration information stored on the server side, obtaining the target Taro source code module according to the configuration information, and establishing a new parent-child repository association relationship. Finally, according to the new parent-child repository association relationship, a second target mini-program is generated.

[0133] Create a Taro source code module using the Taro basic template and native common basic modules to achieve coexistence of multiple frameworks.

[0134] Integrate and compile the Taro source code module to generate a compilation product, and process the subpackage structure configuration information.

[0135] Establish a parent-child repository association relationship, and add the subpackage path information corresponding to each Taro source code module to the target mini-program project configuration.

[0136] Develop pages and components using a general front-end programming language or DSL, and support display on different containers.

[0137] Use the capabilities of different frameworks to compile, build, or package, and deploy the development results to different containers.

[0138] In several embodiments provided in the present application, it should be understood that the disclosed terminals, devices, and methods can be implemented in other ways. For example, the device embodiments described above are merely illustrative. For example, the division of units is only a logical function division. In actual implementation, there may be other division methods. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the displayed or discussed mutual coupling or direct coupling or communication connection may be through some interfaces, and the indirect coupling or communication connection of devices or units may be in an electrical, mechanical, or other form.

[0139] In addition, each functional unit in various embodiments of the present application can be integrated in a processing unit, or each unit can exist physically alone, or two or more units can be integrated in one unit. The above-mentioned integrated unit can be implemented in the form of hardware or in the form of a software functional unit. The above is only the implementation manner of the present application, and does not limit the patent scope of the present application. Any equivalent structure or equivalent process transformation made using the content of the specification and drawings of the present application, or directly or indirectly applied to other related technical fields, is equally included in the patent protection scope of the present application.

Claims

1. An implementation method for coexistence of multiple frameworks in applets based on a cross-terminal framework, characterized in that, The method includes the following steps: S1. Compile projects using different technical frameworks into their respective products: ProjectA is developed using technical framework A, and the product file after compilation is distA, which is then integrated into pageA.js, pageA.json, pageA.wxml, and page.wxss; ProjectB is developed using technical framework B, and the product file after compilation is distB, which is then integrated into pageB.js, pageB.json, pageB.wxml, and page.wxss; ProjectC is developed using technical framework C, and the product file after compilation is distC, which is then integrated into pageC.js, pageC.json, pageC.wxml, and page.wxss; S2. Randomly combine the products for deployment and release: Randomly combine any number of the three products distA, distB, and distC in S1, merge them into the same product dist to release the applet, or use distA / distB / distC alone to release the applet; In the applet miniapp1 merged from distA+distB+distC, pageA, pageB, and pageC can jump to each other; In the applet miniapp2 merged from distA+distB, pageA and pageB can jump to each other; In the applet miniapp3 merged from distA+distC, pageA and pageC can jump to each other; In the applet miniapp4 merged from distB+distC, pageB and pageC can jump to each other; Release the applet miniapp5 using distA alone.

2. The implementation method of coexistence of multiple frameworks for applets based on a cross-terminal framework according to claim 1, characterized in that, The method further includes the following steps: Step 1. Obtain each business module associated with the applet to be developed; Step 2. Provide the Taro basic template and the native common basic module; Step 3. Based on the Taro basic template, create at least one Taro source code module; where each Taro source code module corresponds to one of the business modules; Step 4. Integrate and compile the Taro source code module to obtain the compilation product; Step 5. Integrate the compilation product and the native common basic module to generate and release the first target applet; Step 6. Develop and implement the front-end pages and components using a general front-end programming language or a general DSL; Step 7. Finally deploy the development result in step 6 to different containers and the number of containers is two or more; Step 8. Compile, build, or package the development result in step 6 with the capabilities of two or more different frameworks; Step 9. Deploy the compilation result in step 8 to the containers described in step 7.

3. The implementation method of multi-frame coexistence of applets based on a cross-terminal framework according to claim 2, characterized in that: The general front-end programming languages in step 6 include but are not limited to Javascript, HTML, and CSS; The general DSL includes but is not limited to React and the extended DSL based on the characteristics of React; The general DSL includes, but is not limited to, Vue and extended DSLs based on Vue features; The general DSL includes, but is not limited to, mini-program syntax and extended DSLs based on the syntax features of mini-program syntax.

4. The implementation method of multi-frame coexistence of applets based on a cross-terminal framework according to claim 2, characterized in that: The containers mentioned in step seven include, but are not limited to, Web containers, H5 containers, ReactNative containers, Weex containers, Fultter containers, Electron containers, Tauri containers, or mainstream browsers on the market.

5. The implementation method of multi-frame coexistence of applets based on a cross-terminal framework according to claim 2, characterized in that: The frameworks in step eight include, but are not limited to, cross-terminal frameworks developed according to React technology standards, including, but not limited to, Taro and Rax frameworks; Cross-terminal frameworks developed according to Vue technology standards, including, but not limited to, Chameleon, uni-app, mpvue, and WePY frameworks; Cross-three-terminal frameworks oriented to Native according to Web technology standards, including, but not limited to, ReactNative and Weex frameworks; Cross-terminal frameworks oriented to Native according to other technology standards, including, but not limited to, Flutter.

6. The implementation method of multi-frame coexistence of applets based on a cross-terminal framework according to claim 2, characterized in that, Between step four and step five, there is also a step: obtaining the storage repositories of the Taro source code modules corresponding to each business module; According to the storage repositories of each Taro source code module, generating the subpackage path information corresponding to each Taro source code module; Step five also includes: Adding the subpackage path information corresponding to each Taro source code module to the project configuration of the first target mini-program.

7. The implementation method of multi-frame coexistence of applets based on a cross-terminal framework according to claim 2, characterized in that, Step four includes: identifying the placeholders in each Taro source code module; According to the placeholders, determining the root path in the Taro source code module for referencing files in the mini-program to be developed; After compiling each Taro source code module according to the placeholders and the root path, obtaining the relative path for referencing the file; the compilation product includes the relative path.

8. The implementation method of multi-frame coexistence of applets based on a cross-terminal framework according to claim 2, characterized in that, Step four also includes: obtaining the subpackage structure configuration information corresponding to each Taro source code module; According to the subpackage structure configuration information, generating the public code extraction configuration information and subpackage public file paths of the preset packaging tool; According to the public code extraction configuration information and subpackage public file paths, packaging the subpackage public files from the third-party modules depended on by the Taro source code module.

9. The implementation method of multi-frame coexistence of applets based on a cross-terminal framework according to claim 2, characterized in that, Step four includes: obtaining the release repository corresponding to the first target mini-program; Obtaining the first sub-repositories corresponding to each Taro source code module and the second sub-repository corresponding to the Taro basic template; Establishing a parent-child repository association relationship between the first sub-repository and the release repository, and between the second sub-repository and the release repository respectively; Step five includes: Generating the first target mini-program based on the parent-child repository association relationship.

10. The implementation method of coexistence of multiple frameworks of applets based on a cross-terminal framework according to claim 2, wherein, The method also includes a step: obtaining the Taro module configuration information stored on the server side; According to the Taro module configuration information, obtaining the corresponding target Taro source code module; According to the target Taro source code module, establishing a new parent-child repository association relationship; Generate a second target mini-program according to the new parent-child warehouse association relationship.

Images