ddan-js 2.6.2 → 2.6.4

package/bin/lib/modules/rsa.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const convert_1 = require("./convert");
+const generateKeys = async () => {
+    try {
+        // 生成RSA密钥对
+        const keyPair = await window.crypto.subtle.generateKey({
+            name: 'RSA-OAEP',
+            modulusLength: 2048,
+            publicExponent: new Uint8Array([1, 0, 1]),
+            hash: 'SHA-256',
+        }, true, // 是否可导出密钥
+        ['encrypt', 'decrypt']);
+        // 导出公钥为SPKI格式（可共享）
+        const publicBuffer = await window.crypto.subtle.exportKey('spki', keyPair.publicKey);
+        const publicKey = format_pem_content(publicBuffer);
+        const publicKeyPem = format_pem_key(publicKey, 'PUBLIC KEY');
+        // 导出私钥为PKCS#8格式（需保护）
+        const privateBuffer = await window.crypto.subtle.exportKey('pkcs8', keyPair.privateKey);
+        const privateKey = format_pem_content(privateBuffer);
+        const privateKeyPem = format_pem_key(privateKey, 'PRIVATE KEY');
+        return {
+            publicKey,
+            publicKeyPem,
+            privateKey,
+            privateKeyPem,
+        };
+    }
+    catch (err) {
+        console.error('generateKeys failed:', err);
+    }
+};
+const format_pem_content = (buffer) => {
+    try {
+        const base64String = convert_1.default.ab2str(buffer, true);
+        return base64String.match(/.{1,64}/g)?.join('\n');
+    }
+    catch (error) {
+        return '';
+    }
+};
+const format_pem_key = (pemContent = '', label = 'PUBLIC KEY') => {
+    return `-----BEGIN ${label}-----\n${pemContent}\n-----END ${label}-----`;
+};
+const encrypt = async (data, publicKey) => {
+    try {
+        const encodedData = new TextEncoder().encode(data);
+        const key = await window.crypto.subtle.importKey('spki', convert_1.default.str2ab(publicKey, true), {
+            name: 'RSA-OAEP',
+            hash: 'SHA-256',
+        }, true, ['encrypt']);
+        const encrypted = await window.crypto.subtle.encrypt({
+            name: 'RSA-OAEP',
+        }, key, encodedData);
+        return convert_1.default.ab2str(encrypted, true);
+    }
+    catch (err) {
+        console.error('encrypt failed:', err);
+    }
+};
+const decrypt = async (encryptedData, privateKey) => {
+    try {
+        const encrypted = convert_1.default.str2ab(encryptedData, true);
+        const key = await window.crypto.subtle.importKey('pkcs8', convert_1.default.stringToArrayBuffer(window.atob(privateKey)), {
+            name: 'RSA-OAEP',
+            hash: 'SHA-256',
+        }, true, ['decrypt']);
+        const decrypted = await window.crypto.subtle.decrypt({
+            name: 'RSA-OAEP',
+        }, key, encrypted);
+        const decodedData = new TextDecoder().decode(decrypted);
+        return decodedData;
+    }
+    catch (err) {
+        console.error('decrypt failed:', err);
+    }
+};
+exports.default = {
+    generateKeys,
+    format_pem_key,
+    format_pem_content,
+    encrypt,
+    decrypt
+};

package/bin/types/class/persist.d.ts

@@ -6,9 +6,10 @@ export default class DPersist implements Ddan.IPersist {
     fields: string[];
     constructor(config?: Ddan.IDPersistConfig);
     save: {
-        (...debouncedArgs: any[]): any;
+        (...args: any[]): any;
         cancel: () => void;
         flush: () => any;
+        pending: () => boolean;
     };
     read(): any;
     handleSave(target: Ddan.IDStore, key: string): void;

package/bin/types/index.d.ts

@@ -58,6 +58,7 @@ declare const dUtil: {
     };
     uuid: (len?: number, radix?: number) => string;
     guid: (len: number, prefix?: boolean, sep?: string) => string;
+    getHexString: (len: number) => string;
     keyNumber: string;
     keyLower: string;
     keyUpper: string;
@@ -65,6 +66,10 @@ declare const dUtil: {
     uint8ArrayToString: (arr: any) => string;
     stringToArrayBuffer: (str: any) => ArrayBuffer;
     arrayBufferToString: (data: ArrayBuffer, base64?: boolean) => string;
+    strToHexString: (str: string) => string;
+    hexStringToStr: (hexstr: string) => string;
+    str2ab: (str?: string, base64?: boolean) => ArrayBuffer;
+    ab2str: (data: ArrayBuffer, base64?: boolean) => string;
     gbk: {
         gbkLength: (str: string) => number;
         gbkCut: (source: string, len: number) => string;
@@ -207,6 +212,7 @@ declare const dHook: {
     };
     uuid: (len?: number, radix?: number) => string;
     guid: (len: number, prefix?: boolean, sep?: string) => string;
+    getHexString: (len: number) => string;
     keyNumber: string;
     keyLower: string;
     keyUpper: string;
@@ -214,6 +220,10 @@ declare const dHook: {
     uint8ArrayToString: (arr: any) => string;
     stringToArrayBuffer: (str: any) => ArrayBuffer;
     arrayBufferToString: (data: ArrayBuffer, base64?: boolean) => string;
+    strToHexString: (str: string) => string;
+    hexStringToStr: (hexstr: string) => string;
+    str2ab: (str?: string, base64?: boolean) => ArrayBuffer;
+    ab2str: (data: ArrayBuffer, base64?: boolean) => string;
 };
 declare const dMini: {
     mini: {
@@ -442,6 +452,18 @@ declare const dWeb: {
         isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
         legacyCopy: (text: string) => boolean;
     };
+    rsa: {
+        generateKeys: () => Promise<{
+            publicKey: string | undefined;
+            publicKeyPem: string;
+            privateKey: string | undefined;
+            privateKeyPem: string;
+        } | undefined>;
+        format_pem_key: (pemContent?: string, label?: string) => string;
+        format_pem_content: (buffer: ArrayBuffer) => string | undefined;
+        encrypt: (data: string, publicKey: string) => Promise<string | undefined>;
+        decrypt: (encryptedData: string, privateKey: string) => Promise<string | undefined>;
+    };
 };
 export { dUtil, dHook, dWeb, dMini, dCdn, dStore, dJoker, dTracker, dLogger };
 declare const _default: {
@@ -611,6 +633,7 @@ declare const _default: {
         };
         uuid: (len?: number, radix?: number) => string;
         guid: (len: number, prefix?: boolean, sep?: string) => string;
+        getHexString: (len: number) => string;
         keyNumber: string;
         keyLower: string;
         keyUpper: string;
@@ -750,6 +773,10 @@ declare const _default: {
         uint8ArrayToString: (arr: any) => string;
         stringToArrayBuffer: (str: any) => ArrayBuffer;
         arrayBufferToString: (data: ArrayBuffer, base64?: boolean) => string;
+        strToHexString: (str: string) => string;
+        hexStringToStr: (hexstr: string) => string;
+        str2ab: (str?: string, base64?: boolean) => ArrayBuffer;
+        ab2str: (data: ArrayBuffer, base64?: boolean) => string;
     };
     Event: typeof Event;
     Http: typeof Http;
@@ -787,5 +814,17 @@ declare const _default: {
             fail?: ((error: Error) => void) | undefined;
         }) => Promise<Uint8Array | undefined>;
     };
+    rsa: {
+        generateKeys: () => Promise<{
+            publicKey: string | undefined;
+            publicKeyPem: string;
+            privateKey: string | undefined;
+            privateKeyPem: string;
+        } | undefined>;
+        format_pem_key: (pemContent?: string, label?: string) => string;
+        format_pem_content: (buffer: ArrayBuffer) => string | undefined;
+        encrypt: (data: string, publicKey: string) => Promise<string | undefined>;
+        decrypt: (encryptedData: string, privateKey: string) => Promise<string | undefined>;
+    };
 };
 export default _default;

package/bin/types/modules/convert/index.d.ts

@@ -1,9 +1,15 @@
 declare function uint8ArrayToString(arr: any): string;
 declare function stringToArrayBuffer(str: any): ArrayBuffer;
 declare function arrayBufferToString(data: ArrayBuffer, base64?: boolean): string;
+declare function strToHexString(str: string): string;
+declare function hexStringToStr(hexstr: string): string;
 declare const _default: {
     uint8ArrayToString: typeof uint8ArrayToString;
     stringToArrayBuffer: typeof stringToArrayBuffer;
     arrayBufferToString: typeof arrayBufferToString;
+    strToHexString: typeof strToHexString;
+    hexStringToStr: typeof hexStringToStr;
+    str2ab: (str?: string, base64?: boolean) => ArrayBuffer;
+    ab2str: (data: ArrayBuffer, base64?: boolean) => string;
 };
 export default _default;

package/bin/types/modules/crypto/index.d.ts

@@ -6,6 +6,7 @@ declare const _default: {
     };
     uuid: (len?: number, radix?: number) => string;
     guid: (len: number, prefix?: boolean, sep?: string) => string;
+    getHexString: (len: number) => string;
     keyNumber: string;
     keyLower: string;
     keyUpper: string;

package/bin/types/modules/hook/modules/debounce.d.ts

@@ -7,8 +7,9 @@ import { Ddan } from '../../../typings';
  * @returns
  */
 declare function debounce(func: Ddan.Action, wait?: number, options?: Ddan.IDebounceOption): {
-    (...debouncedArgs: any[]): any;
+    (...args: any[]): any;
     cancel: () => void;
     flush: () => any;
+    pending: () => boolean;
 };
 export default debounce;

package/bin/types/modules/hook/modules/throttle.d.ts

@@ -7,8 +7,9 @@ import { Ddan } from "../../../typings";
  * @returns
  */
 declare function throttle(func: Ddan.Action, wait?: number, options?: Omit<Ddan.IDebounceOption, 'maxWait'>): {
-    (...debouncedArgs: any[]): any;
+    (...args: any[]): any;
     cancel: () => void;
     flush: () => any;
+    pending: () => boolean;
 };
 export default throttle;

package/bin/types/modules/rsa.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    generateKeys: () => Promise<{
+        publicKey: string | undefined;
+        publicKeyPem: string;
+        privateKey: string | undefined;
+        privateKeyPem: string;
+    } | undefined>;
+    format_pem_key: (pemContent?: string, label?: string) => string;
+    format_pem_content: (buffer: ArrayBuffer) => string | undefined;
+    encrypt: (data: string, publicKey: string) => Promise<string | undefined>;
+    decrypt: (encryptedData: string, privateKey: string) => Promise<string | undefined>;
+};
+export default _default;

package/bin/types/typings/index.d.ts

@@ -18,6 +18,7 @@ export declare namespace Ddan {
     type Result<T = any> = T | Promise<T>;
     type SafeResult<T = any> = [any, undefined] | [null, T];
     type PSafeResult<T = any> = Promise<SafeResult<T>>;
+    type noop = (...args: any[]) => any;
     type ObjToKeyValUnion<T> = {
         [K in keyof T]: {
             key: K;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddan-js",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "description": "",
   "keywords": [
     "ddan-js",