xshell 1.2.12 → 1.2.15

package/server.d.ts

@@ -136,6 +136,7 @@ export declare class Server {
         sea?: boolean;
         log_404?: boolean;
     }): Promise<boolean>;
+    log_404(ctx: Context): void;
     /** 将 body 设置为 fp 所指文件的 ReadStream
         检查 fp 是否合法，设置对应的 content-type，支持缓存，支持分块下载
         - ctx: Koa.Context

package/server.js

@@ -572,7 +572,7 @@ export class Server {
             return
         } */
     async try_send(ctx, fp, { fpd_root, assets_root, sea: _sea = sea, log_404 = true, } = {}) {
-        const { request: { _path, path, method }, response, } = ctx;
+        const { request: { method }, response, } = ctx;
         if (response.body !== undefined || response.status !== 404)
             return true;
         if (method !== 'HEAD' && method !== 'GET')
@@ -584,15 +584,15 @@ export class Server {
         catch (error) {
             if (error.status !== 404)
                 throw error;
-            if (log_404 && this.print.logs) {
-                let s = `${' '.repeat(11)}    ${method.toLowerCase()} 404: ${path}`;
-                if (_path !== path)
-                    s += ` ${_path.bracket()}`;
-                console.log(s.red);
-            }
+            if (log_404 && this.print.logs)
+                this.log_404(ctx);
             return false;
         }
     }
+    log_404(ctx) {
+        const { request: { _path, path, method } } = ctx;
+        console.log(`${' '.repeat(15)}${method.toLowerCase()} 404: ${path}${_path === path ? '' : ` ${_path.bracket()}`}`.red);
+    }
     /** 将 body 设置为 fp 所指文件的 ReadStream
         检查 fp 是否合法，设置对应的 content-type，支持缓存，支持分块下载
         - ctx: Koa.Context

package/utils.browser.d.ts

@@ -133,3 +133,7 @@ export declare class Timer {
 export declare function lowercase_first_letter(str: string): string;
 /** 大于 n 的最小的 2 的幂次 */
 export declare function ceil2(n: number): number;
+/** 节流，最多只在时间间隔末尾调用一次，首次调用也延后 */
+export declare function throttle(duration: number, func: Function, delay_first?: boolean): (this: any, ...args: any[]) => void;
+/** 防抖，间隔一段时间不再触发时调用 */
+export declare function debounce(duration: number, func: Function): (this: any, ...args: any[]) => void;

package/utils.browser.js

@@ -211,9 +211,6 @@ export class Lock {
                         reject(error);
                     }
                 // 下面开始释放锁
-                // assert(this.locked)
-                if (!this.locked)
-                    reject(new Error(t('尝试释放未锁定的锁，这不应该发生')));
                 this.locked = false;
                 pcurrent.resolve();
             });
@@ -419,4 +416,49 @@ export function ceil2(n) {
         ;
     return power;
 }
+/** 节流，最多只在时间间隔末尾调用一次，首次调用也延后 */
+export function throttle(duration, func, delay_first = false) {
+    let timeout = 0;
+    let last = 0;
+    let saved_this = null;
+    let saved_args = null;
+    return function throttled(...args) {
+        // 当前时间间隔已预定执行，本次调用仅更新调用参数
+        if (timeout) {
+            saved_this = this;
+            saved_args = args;
+            return;
+        }
+        const now = Date.now();
+        if (last === 0 && delay_first)
+            last = now;
+        const ellapsed = now - last;
+        // 过了时间间隔末尾，直接执行
+        if (ellapsed >= duration) {
+            last = now;
+            func.apply(this, args);
+        }
+        else { // 预定在间隔末尾执行
+            saved_this = this;
+            saved_args = args;
+            timeout = setTimeout(() => {
+                timeout = null;
+                last = Date.now();
+                func.apply(saved_this, saved_args);
+                saved_this = null;
+                saved_args = null;
+            }, duration - ellapsed);
+        }
+    };
+}
+/** 防抖，间隔一段时间不再触发时调用 */
+export function debounce(duration, func) {
+    let timeout = null;
+    return function debounced(...args) {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            func.apply(this, args);
+        }, duration);
+    };
+}
 //# sourceMappingURL=utils.browser.js.map

package/utils.d.ts

@@ -210,3 +210,7 @@ export declare function consume_stream(stream: Readable, ignore_error?: boolean)
 export declare function range_to_numbers(range: string, reverse?: boolean): Generator<number, void, unknown>;
 /** 大于 n 的最小的 2 的幂次 */
 export declare function ceil2(n: number): number;
+/** 节流，最多只在时间间隔末尾调用一次，首次调用也延后 */
+export declare function throttle(duration: number, func: Function, delay_first?: boolean): (this: any, ...args: any[]) => void;
+/** 防抖，间隔一段时间不再触发时调用 */
+export declare function debounce(duration: number, func: Function): (this: any, ...args: any[]) => void;

package/utils.js

@@ -415,9 +415,6 @@ export class Lock {
                         reject(error);
                     }
                 // 下面开始释放锁
-                // assert(this.locked)
-                if (!this.locked)
-                    reject(new Error(t('尝试释放未锁定的锁，这不应该发生')));
                 this.locked = false;
                 pcurrent.resolve();
             });
@@ -695,4 +692,49 @@ export function ceil2(n) {
         ;
     return power;
 }
+/** 节流，最多只在时间间隔末尾调用一次，首次调用也延后 */
+export function throttle(duration, func, delay_first = false) {
+    let timeout = null;
+    let last = 0;
+    let saved_this = null;
+    let saved_args = null;
+    return function throttled(...args) {
+        // 当前时间间隔已预定执行，本次调用仅更新调用参数
+        if (timeout) {
+            saved_this = this;
+            saved_args = args;
+            return;
+        }
+        const now = Date.now();
+        if (last === 0 && delay_first)
+            last = now;
+        const ellapsed = now - last;
+        // 过了时间间隔末尾，直接执行
+        if (ellapsed >= duration) {
+            last = now;
+            func.apply(this, args);
+        }
+        else { // 预定在间隔末尾执行
+            saved_this = this;
+            saved_args = args;
+            timeout = setTimeout(() => {
+                timeout = null;
+                last = Date.now();
+                func.apply(saved_this, saved_args);
+                saved_this = null;
+                saved_args = null;
+            }, duration - ellapsed);
+        }
+    };
+}
+/** 防抖，间隔一段时间不再触发时调用 */
+export function debounce(duration, func) {
+    let timeout = null;
+    return function debounced(...args) {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            func.apply(this, args);
+        }, duration);
+    };
+}
 //# sourceMappingURL=utils.js.map