docs: remove deprecated api

Author: ShrBox

docs/apis/ScriptAPI/Ll.md

@@ -25,27 +25,6 @@ Some interfaces related to loader operations are provided here.
 - Return value: loader version
 - Return value type:  `String`
 
-
-
-### Check LeviLamina version
-
-`ll.requireVersion(major[,minor,revision])`
-
-- Parameter: 
-  - major: `Integer`  
-    Check if the major version number of the currently installed LL is >= this value.
-  - minor: `Integer` (optional parameter)
-    Check if the minor version number of the currently installed LL is >= this value.
-  - revision: `Integer` (optional parameter)  
-    Check if the revision number of the currently installed LL is >= this value.
-- Return value: Test result
-- Return value type:  `Boolean`
-
-If the detection finds that the currently installed version of LLSE is lower than the value passed in, it will return `false`. 
-You can choose to judge based on the results and report an error to remind users to upgrade their LeviLamina version.
-
-
-
 ### Get information about Plugin
 
 `ll.getPluginInfo(name)`
@@ -66,27 +45,20 @@ You can choose to judge based on the results and report an error to remind users
   | plugin.filePath   | Path to plugin          | `String`                         |
   | plugin.others     | Other information       | `Object`                         |
 
-
-
-
 ### List all loaded plugins
 
 `ll.listPlugins()`
 
 - Return value: A list containing the names of all loaded plugin
 - Return value type:  `Array<String,String,...>`
 
-
-
 ### List all loaded plugins with information
 
 `ll.getAllPluginInfo()`
 
 - Return value: A list containing the plugin objects of all loaded plugin
 - Return value type:  `Array<Plugin,Plugin,...>`
 
-
-
 ### Remote Function Call
 
 In order to allow the pre-plug-ins developed by developers to provide interfaces and services for other plug-ins, the remote function call function is provided here, so that one LLSE plug-in can call the existing functions in another plug-in. 
@@ -109,8 +81,6 @@ In order to allow the pre-plug-ins developed by developers to provide interfaces
 
 Note: If the namespace and name of the exported function are exactly the same as another already exported function, the export will fail. Please select the namespace and export name appropriately when exporting.
 
-
-
 #### Import Function
 
 After you have learned that there is a plug-in exporting function, in order to use the function exported by him, you first need to import this function into your own scripting system.
@@ -128,8 +98,6 @@ LLSE provides the interface import to import functions already exported by other
 
 The return value of `ll.import` is a function. When you call this function, the cross-plugin call process will be done automatically in the background. The parameters of the calling function will be wrapped and passed to the remote function, and the return value of this function is the return value returned by the remote function after it has been executed.
 
-
-
 #### Example of Remote Calling Function 
 
 For example, there is a plug-in that exports a function using the namespace AAA, and the name of the exported function is Welcome
@@ -141,8 +109,6 @@ The parameters of the function will be automatically forwarded to the correspond
 
 Notice! When calling a function, you need to ensure that the number and types of parameters you pass in and the parameters accepted by the target function are correct and in one-to-one correspondence. Otherwise, an error will occur. 
 
-
-
 ### Determine if a remote function has been exported
 
 `ll.hasExported(namespace,name)`
@@ -155,41 +121,6 @@ Notice! When calling a function, you need to ensure that the number and types of
 - Return value：Whether the function has been exported
 - Return value type： `Boolean`
 
-
-
-### Set Plugin Dependencies 
-
-Sometimes, you need to make sure that certain plugins are loaded before your own plugins to use the frontend services provided by them. We call these frontend plugins **library dependencies**.
-
-When using the import function mentioned above, you need to pay attention: the premise of being able to import a function is that the pre-plugin to be called has been loaded by LLSE.
-Therefore, you may need to use the following function to set the dependent library, so that the pre-plugins you need are loaded first and the import is successful.
-
-LLSE provides the following interface to preload the dependent libraries required by the plugin, download the dependent library files you need from local files, or even from remote HTTP(s) addresses.
-
-`ll.require(path[,remotePath])`
-
-- Parameter: 
-  - path : `String`  
-    Library dependency filename (Example: `addplugin.js`)
-  - remotePath : `String`  
-    (Optional parameter) The path to find and load dependent libraries, see below for instructions.
-- Return value: Whether the dependent library is loaded successfully 
-- Return value type:  `Boolean`
-
-For execution, use `ll.require`, then LLSE will perform the following series of operations:
-
-- Search the list of loaded plugins. If the dependent library has been loaded, it will return success directly.
-- Search **plugins** and **plugins/lib** directories, if the corresponding dependent library file is found, load it and return the loading result.
-- If the corresponding dependent library file is not found after the search is completed, and the remotePath parameter is not passed in, it will return directly to failure.
-- Use the HTTP(s) protocol remotePath to request the download address corresponding to the remotePath parameter, and download the dependent library files to the `plugins/lib` directory. If the download fails, return failure.
-- Load the successfully downloaded dependent library file and return the loading result.
-
-
-
-Authors of dependent libraries can host relevant code on stable large websites such as GitHub or Gitee, and provide external links to other developers for remote download.
-
-
-
 ### Execute a String as a Script
 
 `ll.eval(str)`
@@ -199,5 +130,3 @@ Authors of dependent libraries can host relevant code on stable large websites s
     String to execute as a Script
 - Return value: Execution result
 - Return value type:  `Any Type`
-
-Different from the above mentioned `ll.require`, the script code executed here is directly executed in the engine corresponding to the current plugin, similar to the eval mechanism of each language.

docs/apis/ScriptAPI/Ll.zh.md

@@ -26,27 +26,6 @@
 - 返回值：加载器版本
 - 返回值类型： `String`
 
-
-
-### 检查 LeviLamina 版本
-
-`ll.requireVersion(major[,minor,revision])`
-
-- 参数：
-  - major: `Integer`  
-    检查当前已安装LeviLamina的主版本号是否 >= 此值
-  - minor: `Integer`（可选参数）  
-    检查当前已安装LeviLamina的次版本号是否 >= 此值
-  - revision: `Integer`（可选参数）  
-    检查当前已安装LeviLamina的修订版本号是否 >= 此值
-- 返回值：检查结果
-- 返回值类型： `Boolean`
-
-如果检测发现当前安装的脚本引擎版本低于传入的数值，将返回`false`。  
-你可以选择根据结果判断并报错，提醒用户升级自己的LeviLamina版本
-
-
-
 ### 获取有关插件的信息
 
 `ll.getPluginInfo(name)`
@@ -68,26 +47,20 @@
   | plugin.filePath   | 插件路径             | `String`                         |
   | plugin.others     | 其他信息             | `Object`                         |
 
-
-
 ### 列出所有已加载的插件
 
 `ll.listPlugins()`
 
 - 返回值：已加载的所有的插件名字列表
 - 返回值类型： `Array<String,String,...>`
 
-
-
 ### 列出所有加载的插件信息
 
 `ll.getAllPluginInfo()`
 
 - 返回值: 包含所有已加载插件的插件对象的列表
 - 返回值类型:  `Array<Plugin,Plugin,...>`
 
-
-
 ### 远程函数调用
 
 #### 导出函数
@@ -108,8 +81,6 @@
 
 注意：如果导出的函数的命名空间和名字与另一个已经导出的函数完全相同，将会导出失败。选定命名空间和导出名称时请适当选择。
 
-
-
 #### 导入函数
 
 当你已经得知有插件导出函数之后，为了可以使用他导出的函数，首先需要将这个函数导入到你自己的脚本系统中  
@@ -127,8 +98,6 @@
 
 `ll.import` 的返回值是一个函数。当你调用这个函数时，跨插件调用的流程将在后台自动完成。调用函数的参数将被包装并传递给远程函数，此函数的返回值即是远程函数执行完毕之后返回的返回值。
 
-
-
 #### 远程调用参数类型对照，其中Type可以为其他受支持的类型
 
 | C++层类型                                     | 脚本引擎类型  | .NET托管类型                             | 内部类型（备注）                       |
@@ -160,8 +129,6 @@
 
 注意！在调用函数的时候，需要保证你传入的参数和目标函数接受的参数数量和类型都是正确且一一对应的。否则，将会发生错误。
 
-
-
 ### 判断远程函数是否已导出
 `ll.hasExported(namespace,name)`
 
@@ -173,41 +140,6 @@
 - 返回值：函数是否已导出
 - 返回值类型： `Boolean`
 
-
-
-### 设置插件依赖库
-
-有的时候，你需要确保某些插件在你自己的插件之前加载，以使用他们提供的前置服务，我们称这些前置插件为**依赖库**。
-
-在使用上述提到的导入函数时，你需要注意：能够导入一个函数的前提是要被调用的前置插件已经被脚本引擎加载。  
-因此，你可能需要用下面的函数来设置依赖库，让你需要的前置插件被优先加载，保证导入成功
-
-脚本引擎提供了下面的接口来提前加载插件所需要的依赖库，从本地文件，甚至可以从远程HTTP(s)地址下载你所需的依赖库文件
-
-`ll.require(path[,remotePath])`
-
-- 参数：
-  - path : `String`  
-    依赖库文件名（如`addplugin.js`)
-  - remotePath : `String`  
-    （可选参数）查找并装载依赖库的路径，说明见下
-- 返回值：是否加载依赖库成功
-- 返回值类型： `Boolean`
-
-在执行`ll.require`后，脚本引擎将进行如下一系列操作
-
-- 搜索已加载插件列表。如果依赖库已经被加载，则直接返回成功。
-- 搜索 **plugins** 和 **plugins/lib** 目录，如果发现对应的依赖库文件，则加载，并返回加载结果
-- 如果搜索完毕之后未发现对应的依赖库文件，且 remotePath 参数也未传入，则直接返回失败
-- 使用 HTTP(s) 协议请求 remotePath 参数对应的下载地址，并下载依赖库文件到 **plugins/lib** 目录。如果下载失败，则返回失败
-- 加载下载成功的依赖库文件，并返回加载结果
-
-
-
-依赖库作者可以将相关代码托管在GitHub或Gitee等稳定的大型网站上，并将外链提供给其他开发者以供远程下载使用。
-
-
-
 ### 将字符串作为脚本代码执行
 
 `ll.eval(str)`
@@ -218,4 +150,3 @@
 - 返回值：执行结果
 - 返回值类型： `任意类型`
 
-不同于上面提到的的`ll.require`，此处执行的脚本代码是在当前插件对应的引擎中直接执行的，类似于各语言的 eval 机制

src/legacy/api/LlAPI.cpp

@@ -68,14 +68,11 @@ Local<Value> LlClass::isWine() {
 }
 
 auto LlClass::isDebugMode() -> Local<Value> {
-    try {
 #ifdef NDEBUG
-        return Boolean::newBoolean(false);
+    return Boolean::newBoolean(false);
 #else
-        return Boolean::newBoolean(true);
+    return Boolean::newBoolean(true);
 #endif
-    }
-    CATCH("Fail in LLSEIsDebugMode")
 }
 
 Local<Value> LlClass::isRelease() {
@@ -92,12 +89,7 @@ Local<Value> LlClass::isBeta() {
     CATCH("Fail in LLSEIsBeta")
 }
 
-Local<Value> LlClass::isDev() {
-    try {
-        return Boolean::newBoolean(false);
-    }
-    CATCH("Fail in LLSEIsDev")
-}
+Local<Value> LlClass::isDev() { return Boolean::newBoolean(false); }
 
 Local<Value> LlClass::getMajorVersion() {
     try {
@@ -127,19 +119,9 @@ Local<Value> LlClass::getScriptEngineVersion() {
     CATCH("Fail in LLSEGetScriptEngineVerison")
 }
 
-Local<Value> LlClass::getVersionStatus() {
-    try {
-        return Number::newNumber(0);
-    }
-    CATCH("Fail in LLSEGetVersionStatus")
-}
+Local<Value> LlClass::getVersionStatus() { return Number::newNumber(0); }
 
-Local<Value> LlClass::registerPlugin(const Arguments& args) {
-    try {
-        return Boolean::newBoolean(true);
-    }
-    CATCH("Fail in LLAPI");
-}
+Local<Value> LlClass::registerPlugin(const Arguments& args) { return Boolean::newBoolean(true); }
 Local<Value> LlClass::getPluginInfo(const Arguments& args) {
     try {
         auto plugin = lse::getPluginManager().getPlugin(args[0].asString().toString());
@@ -180,13 +162,7 @@ Local<Value> LlClass::versionString(const Arguments& args) {
     CATCH("Fail in LLSEGetVersionString!")
 }
 
-Local<Value> LlClass::requireVersion(const Arguments& args) {
-
-    try {
-        return Boolean::newBoolean(true);
-    }
-    CATCH("Fail in LLSERequireVersion!")
-}
+Local<Value> LlClass::requireVersion(const Arguments& args) { return Boolean::newBoolean(true); }
 
 Local<Value> LlClass::getAllPluginInfo(const Arguments& args) {
     try {
@@ -240,12 +216,8 @@ Local<Value> LlClass::listPlugins(const Arguments& args) {
     CATCH("Fail in LLAPI");
 }
 
-Local<Value> LlClass::require(const Arguments& args) {
-    try {
-        return {};
-    }
-    CATCH("Fail in LLAPI");
-}
+Local<Value> LlClass::require(const Arguments& args) { return Boolean::newBoolean(true); }
+
 Local<Value> LlClass::eval(const Arguments& args) {
     CHECK_ARGS_COUNT(args, 1);
     CHECK_ARG_TYPE(args[0], ValueKind::kString);
@@ -275,14 +247,11 @@ Local<Value> LlClass::version(const Arguments& args) {
 
 // For Compatibility
 Local<Value> LlClass::isDebugModeFunction(const Arguments& args) {
-    try {
 #ifdef LEGACYSCRIPTENGINE_DEBUG
-        return Boolean::newBoolean(true);
+    return Boolean::newBoolean(true);
 #else
-        return Boolean::newBoolean(false);
+    return Boolean::newBoolean(false);
 #endif
-    }
-    CATCH("Fail in LLSEGetIsDebugModeFunction")
 }
 
 // For Compatibility