Update TypeScript Declaration

SheepChef · SheepChef · commit 2330f20ddec6 · 2025-08-03T17:27:03.000+08:00
Thinking if WenyanConfig should be exposed.
diff --git a/src/javascript/CoreHandler.js b/src/javascript/CoreHandler.js
@@ -22,6 +22,14 @@ import {
 } from "./Misc.js";
 
 export class WenyanConfig {
+  /**
+   * 魔曰 文言文加密参数
+   *
+   * @param{bool}PunctuationMark 指定是否为密文添加标点符号，默认 true/添加;
+   * @param{int}RandomIndex 密文算法的随机程度，越大随机性越强，默认 50，最大100，超过100将会出错;
+   * @param{bool}PianwenMode 指定是否强制生成骈文密文，默认 false;
+   * @param{bool}LogicMode 指定是否强制生成逻辑密文，默认 false;
+   */
   constructor(
     PunctuationMark = true,
     RandomIndex = 50,
@@ -62,10 +70,16 @@ export function Enc(input, key, WenyanConfigObj) {
   //映射
   let Res = WenyanSimulatorObj.enMap(
     OriginStr,
-    WenyanConfigObj.PunctuationMark,
-    WenyanConfigObj.RandomIndex,
-    WenyanConfigObj.PianwenMode,
-    WenyanConfigObj.LogicMode
+    WenyanConfigObj.PunctuationMark !== undefined
+      ? WenyanConfigObj.PunctuationMark
+      : true,
+    WenyanConfigObj.RandomIndex !== undefined
+      ? WenyanConfigObj.RandomIndex
+      : 50,
+    WenyanConfigObj.PianwenMode !== undefined
+      ? WenyanConfigObj.PianwenMode
+      : false,
+    WenyanConfigObj.LogicMode !== undefined ? WenyanConfigObj.LogicMode : false
   );
 
   return Res;
diff --git a/src/javascript/main.d.ts b/src/javascript/main.d.ts
@@ -1,4 +1,15 @@
 declare module "abracadabra-cn";
+
+export interface WenyanConfig {
+  /** 指定是否为密文添加标点符号，默认 true/添加; */
+  PunctuationMark?: boolean;
+  /** 密文算法的随机程度，越大随机性越强，默认 50，最大100，超过100将会出错; */
+  RandomIndex?: number;
+  /** 指定是否强制生成骈文密文，默认 false; */
+  PianwenMode?: boolean;
+  /** 指定是否强制生成逻辑密文，默认 false; */
+  LogicMode?: boolean;
+}
 export class Abracadabra {
   static TEXT: "TEXT";
   static UINT8: "UINT8";
@@ -14,6 +25,22 @@ export class Abracadabra {
    */
   constructor(inputType?: "TEXT" | "UINT8", outputType?: "TEXT" | "UINT8");
 
+  /**
+   * 魔曰 文言文加密模式
+   *
+   * @param {string | Uint8Array} input 输入的数据，根据此前指定的输入类型，可能是字符串或字节数组
+   * @param {string} mode 指定模式，可以是 ENCRYPT DECRYPT 中的一种;
+   * @param {string} key 指定密钥，默认是 ABRACADABRA;
+   * @param {WenyanConfig} WenyanConfigObj 文言文的生成配置;
+   * @return {number} 成功则返回 0（失败不会返回，会抛出异常）
+   */
+  WenyanInput(
+    input: string | Uint8Array,
+    mode: "ENCRYPT" | "DECRYPT",
+    key?: string,
+    WenyanConfigObj?: WenyanConfig
+  ): number;
+
   /**
    * 魔曰 传统加密模式
    *
@@ -23,22 +50,36 @@ export class Abracadabra {
    * @param {bool} q 指定是否在加密后省略标志位，默认 false/不省略;
    * @return {number} 成功则返回 0（失败不会返回，会抛出异常）
    */
-  Input(
+  OldInput(
     input: string | Uint8Array,
     mode: "ENCRYPT" | "DECRYPT" | "AUTO",
     key?: string,
     q?: boolean
   ): number;
 
   /**
-   * 魔曰 获取加密/解密后的结果
-   * @returns {string | Uint8Array} 根据此前指定的输出类型，可能是字符串或字节数组
+   * 魔曰 传统加密模式
+   *
+   * **这是一个过时的接口，请尽可能切换到新接口 OldInput()**
+   *
+   * @param {string | Uint8Array} input 输入的数据，根据此前指定的输入类型，可能是字符串或字节数组
+   * @param {string} mode 指定模式，可以是 ENCRYPT DECRYPT AUTO 中的一种;
+   * @param {string} key 指定密钥，默认是 ABRACADABRA;
+   * @param {bool} q 指定是否在加密后省略标志位，默认 false/不省略;
+   * @return {number} 成功则返回 0（失败不会返回，会抛出异常）
    */
-  Output(): string | Uint8Array;
+  Input(
+    input: string | Uint8Array,
+    mode: "ENCRYPT" | "DECRYPT" | "AUTO",
+    key?: string,
+    q?: boolean
+  ): number;
 
   /**
    * 魔曰 文言文加密模式
    *
+   * **这是一个过时的接口，请尽可能切换到新接口 WenyanInput()**
+   *
    * @param {string | Uint8Array} input 输入的数据，根据此前指定的输入类型，可能是字符串或字节数组
    * @param {string} mode 指定模式，可以是 ENCRYPT DECRYPT 中的一种;
    * @param {string} key 指定密钥，默认是 ABRACADABRA;
@@ -57,4 +98,10 @@ export class Abracadabra {
     p?: boolean,
     l?: boolean
   ): number;
+
+  /**
+   * 魔曰 获取加密/解密后的结果
+   * @returns {string | Uint8Array} 根据此前指定的输出类型，可能是字符串或字节数组
+   */
+  Output(): string | Uint8Array;
 }
diff --git a/src/javascript/main.js b/src/javascript/main.js
@@ -32,7 +32,6 @@ import { Base64 } from "js-base64";
 import * as Core from "./CoreHandler.js";
 //import * as Util_Next from "./utils_next.js";
 import { preCheck_OLD, PreCheckResult, stringToUint8Array } from "./Misc.js";
-
 export class Abracadabra {
   //主类
 
@@ -71,9 +70,14 @@ export class Abracadabra {
    * @param{string | Uint8Array}input 输入的数据，根据此前指定的输入类型，可能是字符串或字节数组
    * @param{string}mode 指定模式，可以是 ENCRYPT DECRYPT 中的一种;
    * @param{string}key 指定密钥，默认是 ABRACADABRA;
-   * @param{Core.WenyanConfig}WenyanConfigObj 文言文的生成配置;
+   * @param{WenyanConfig}WenyanConfigObj 文言文的生成配置;
    */
-  WenyanInput(input, mode, key = "ABRACADABRA", WenyanConfigObj) {
+  WenyanInput(
+    input,
+    mode,
+    key = "ABRACADABRA",
+    WenyanConfigObj = new Core.WenyanConfig(true, 50, false, false)
+  ) {
     if (this.#input == Abracadabra.UINT8) {
       //如果指定输入类型是UINT8
       if (Object.prototype.toString.call(input) != "[object Uint8Array]") {
diff --git a/src/javascript/main.test.js b/src/javascript/main.test.js
@@ -56,41 +56,38 @@ test("加/解密测试", { timeout: 15000 }, () => {
 
   //将随机字符串用仿真加密循环加/解密6次，判断一致性和中途是否出错。
   for (let i = 0; i <= 6; i++) {
-    Abra.Input_Next(
-      TestTemp,
-      "ENCRYPT",
-      "ABRACADABRA",
-      i % 2 == 0,
-      50,
-      i % 2 == 0,
-      i % 2 != 0
-    );
+    Abra.WenyanInput(TestTemp, "ENCRYPT", "ABRACADABRA", {
+      PunctuationMark: i % 2 == 0,
+      RandomIndex: 50,
+      PianwenMode: i % 2 == 0,
+      LogicMode: i % 2 != 0,
+    });
     TestTemp = Abra.Output();
   }
 
   for (let i = 0; i <= 6; i++) {
-    Abra.Input_Next(TestTemp, "DECRYPT", "ABRACADABRA");
+    Abra.WenyanInput(TestTemp, "DECRYPT", "ABRACADABRA");
     TestTemp = Abra.Output();
   }
 
   //将随机字符串用传统加密循环加/解密6次，判断一致性和中途是否出错。
   for (let i = 0; i <= 6; i++) {
-    Abra.Input(TestTemp2, "ENCRYPT", "ABRACADABRA", true);
+    Abra.OldInput(TestTemp2, "ENCRYPT", "ABRACADABRA", true);
     TestTemp2 = Abra.Output();
   }
 
   for (let i = 0; i <= 6; i++) {
-    Abra.Input(TestTemp2, "DECRYPT", "ABRACADABRA");
+    Abra.OldInput(TestTemp2, "DECRYPT", "ABRACADABRA");
     TestTemp2 = Abra.Output();
   }
   expect(TestTemp).toBe(TestString);
   expect(TestTemp2).toBe(TestString);
 
   //测试传统加密标志位
 
-  Abra.Input(TestTemp3, "AUTO", "ABRACADABRA");
+  Abra.OldInput(TestTemp3, "AUTO", "ABRACADABRA");
   TestTemp3 = Abra.Output();
-  Abra.Input(TestTemp3, "AUTO", "ABRACADABRA");
+  Abra.OldInput(TestTemp3, "AUTO", "ABRACADABRA");
   TestTemp3 = Abra.Output();
 
   expect(TestTemp3).toBe(TestString);
@@ -104,14 +101,16 @@ test("链接压缩测试", { timeout: 15000 }, () => {
     //测试不同链接的加解密一致性
     let TestTemp = "";
     let TestTemp2 = "";
-    Abra.Input_Next(item, "ENCRYPT", "ABRACADABRA", true, 100);
+    Abra.WenyanInput(item, "ENCRYPT", "ABRACADABRA", {
+      RandomIndex: 100,
+    });
     TestTemp = Abra.Output();
-    Abra.Input_Next(TestTemp, "DECRYPT", "ABRACADABRA");
+    Abra.WenyanInput(TestTemp, "DECRYPT", "ABRACADABRA");
     TestTemp = Abra.Output();
 
-    Abra.Input(item, "ENCRYPT", "ABRACADABRA", true);
+    Abra.OldInput(item, "ENCRYPT", "ABRACADABRA", true);
     TestTemp2 = Abra.Output();
-    Abra.Input(TestTemp2, "DECRYPT", "ABRACADABRA");
+    Abra.OldInput(TestTemp2, "DECRYPT", "ABRACADABRA");
     TestTemp2 = Abra.Output();
 
     expect(TestTemp).toBe(item);
@@ -127,20 +126,22 @@ test("随机数据加密测试", { timeout: 15000 }, () => {
     let TestTemp;
     let TestTemp2;
     let TestTemp3;
-    Abra.Input_Next(data, "ENCRYPT", "ABRACADABRA", true, 100);
+    Abra.WenyanInput(data, "ENCRYPT", "ABRACADABRA", {
+      RandomIndex: 100,
+    });
     TestTemp = Abra.Output();
-    Abra.Input_Next(TestTemp, "DECRYPT", "ABRACADABRA");
+    Abra.WenyanInput(TestTemp, "DECRYPT", "ABRACADABRA");
     TestTemp = Abra.Output();
 
-    Abra.Input(data, "ENCRYPT", "ABRACADABRA", true);
+    Abra.OldInput(data, "ENCRYPT", "ABRACADABRA", true);
     TestTemp2 = Abra.Output();
-    Abra.Input(TestTemp2, "DECRYPT", "ABRACADABRA");
+    Abra.OldInput(TestTemp2, "DECRYPT", "ABRACADABRA");
     TestTemp2 = Abra.Output();
 
     //传统模式，自动判别
-    Abra.Input(data, "AUTO", "ABRACADABRA");
+    Abra.OldInput(data, "AUTO", "ABRACADABRA");
     TestTemp3 = Abra.Output();
-    Abra.Input(TestTemp3, "AUTO", "ABRACADABRA");
+    Abra.OldInput(TestTemp3, "AUTO", "ABRACADABRA");
     TestTemp3 = Abra.Output();
 
     expect(TestTemp).toStrictEqual(data);
