xshell 1.3.8 → 1.3.10

package/utils.d.ts

@@ -1,4 +1,4 @@
-import { Writable, Transform, type Readable, type Duplex, type TransformCallback } from 'node:stream';
+import { Writable, Transform, type Readable, type TransformCallback } from 'node:stream';
 import util from 'node:util';
 import './prototype.ts';
 import './platform.ts';
@@ -11,7 +11,7 @@ export declare function typed_array_to_buffer(view: ArrayBufferView): Buffer<Arr
 /** 每天在固定时间执行操作
     - hour: 0 - 23 之间的整数，在这个点执行
     - action */
-export declare function schedule_everyday(hour: number, action: () => Promise<void>): Promise<void>;
+export declare function schedule_everyday(hour: number, minute: number, action: () => Promise<void>): Promise<void>;
 export declare function log_line(): void;
 export declare function sha256(data: string | Uint8Array): string;
 export declare function sha1(data: string | Uint8Array): string;
@@ -31,19 +31,8 @@ export declare namespace inspect {
     const custom: typeof util.inspect.custom;
     const defaultOptions: util.InspectOptions;
 }
-/** npm map-stream
-    filter will reemit the data if cb(err,pass) pass is truthy
-    
-    reduce is more tricky
-    maybe we want to group the reductions or emit progress updates occasionally
-    the most basic reduce just emits one 'data' event after it has recieved 'end'
-    
-    create an event stream and apply function to each .write,
-    emitting each response as data unless it's an empty callback
- */
-export declare function map_stream<Out, In = any>(mapper: (obj: In, cb: Function) => any, options?: {
-    failures?: boolean;
-}): Duplex;
+/** 消费一个可读流 */
+export declare function consume_stream(stream: Readable, ignore_error?: boolean): Promise<void>;
 export declare function stream_to_lines(stream: Readable): AsyncGenerator<string, void, unknown>;
 export declare class WritableMemoryStream extends Writable {
     chunks: Uint8Array[];
@@ -65,8 +54,6 @@ export declare class DecoderStream extends Transform {
     _transform(chunk: Uint8Array, encoding: BufferEncoding, callback: TransformCallback): void;
     _flush(callback: TransformCallback): void;
 }
-/** 消费一个可读流 */
-export declare function consume_stream(stream: Readable, ignore_error?: boolean): Promise<void>;
 /** 根据 range 生成整数序列 (iterable)
     - range: 取值为逗号分割的多个可用值或值区间 (不能含有空格)，比如：`8321,8322,8300-8310,11000-11999`
     - reverse?: `false` 在 range 内从后往前生成 */

package/utils.js

@@ -1,4 +1,4 @@
-import { Stream, Writable, Transform } from 'node:stream';
+import { Writable, Transform } from 'node:stream';
 import util from 'node:util';
 import ncrypto from 'node:crypto';
 import "./prototype.js";
@@ -30,10 +30,10 @@ export function typed_array_to_buffer(view) {
 /** 每天在固定时间执行操作
     - hour: 0 - 23 之间的整数，在这个点执行
     - action */
-export async function schedule_everyday(hour, action) {
+export async function schedule_everyday(hour, minute, action) {
     const now = Date.now();
     let target = new Date();
-    target.setHours(hour, 0, 0, 0);
+    target.setHours(hour, minute, 0, 0);
     // 如果目标时间已过，设定为明天的时间
     if (now > target.getTime())
         target.setDate(target.getDate() + 1);
@@ -94,120 +94,16 @@ export function colored(str, color, enabled = inspect.defaultOptions.colors) {
     inspect.defaultOptions = util.inspect.defaultOptions;
 })(inspect || (inspect = {}));
 // ------------------------------------ stream
-/** npm map-stream
-    filter will reemit the data if cb(err,pass) pass is truthy
-    
-    reduce is more tricky
-    maybe we want to group the reductions or emit progress updates occasionally
-    the most basic reduce just emits one 'data' event after it has recieved 'end'
-    
-    create an event stream and apply function to each .write,
-    emitting each response as data unless it's an empty callback
- */
-export function map_stream(mapper, options) {
-    options = options || {};
-    let inputs = 0, outputs = 0, ended = false, paused = false, destroyed = false, last_written = 0, in_next = false;
-    let stream = Object.assign(new Stream(), {
-        readable: true,
-        writable: true,
-        write(data) {
-            if (ended)
-                throw new Error('map stream is not writable');
-            in_next = false;
-            inputs++;
-            try {
-                // catch sync errors and handle them like async errors
-                const written = wrapped_mapper(data, inputs, next);
-                paused = (written === false);
-                return !paused;
-            }
-            catch (err) {
-                // if the callback has been called syncronously, and the error has occured in an listener, throw it again.
-                if (in_next)
-                    throw err;
-                next(err);
-                return !paused;
-            }
-        },
-        end(data) {
-            if (ended)
-                return;
-            _end(data);
-        },
-        destroy() {
-            ended = destroyed = true;
-            stream.writable = stream.readable = paused = false;
-            process.nextTick(function () {
-                stream.emit('close');
-            });
-        },
-        pause() {
-            paused = true;
-        },
-        resume() {
-            paused = false;
-        }
-    });
-    let error_event_name = options.failures ? 'failure' : 'error';
-    // Items that are not ready to be written yet (because they would come out of order) get stuck in a queue for later.
-    let write_queue = {};
-    function queue_data(data, number) {
-        let next_to_write = last_written + 1;
-        if (number === next_to_write) {
-            // If it's next, and its not undefined write it
-            if (data !== undefined)
-                stream.emit('data', data);
-            last_written++;
-            next_to_write++;
-        }
-        else
-            // Otherwise queue it for later.
-            write_queue[number] = data;
-        // If the next value is in the queue, write it
-        if (Object.prototype.hasOwnProperty.call(write_queue, next_to_write)) {
-            let data_to_write = write_queue[next_to_write];
-            delete write_queue[next_to_write];
-            return queue_data(data_to_write, next_to_write);
-        }
-        outputs++;
-        if (inputs === outputs) {
-            if (paused) {
-                paused = false;
-                stream.emit('drain'); // written all the incoming events
-            }
-            if (ended)
-                _end();
-        }
-    }
-    function next(err, data, number) {
-        if (destroyed)
-            return;
-        in_next = true;
-        if (!err || options.failures)
-            queue_data(data, number);
-        if (err)
-            stream.emit(error_event_name, err);
-        in_next = false;
-    }
-    /** Wrap the mapper function by calling its callback with the order number of the item in the stream. */
-    function wrapped_mapper(input, number, callback) {
-        return mapper.call(null, input, function (err, data) {
-            callback(err, data, number);
-        });
+/** 消费一个可读流 */
+export async function consume_stream(stream, ignore_error = false) {
+    try {
+        for await (const chunk of stream)
+            ;
     }
-    function _end(data) {
-        // if end was called with args, write it, 
-        ended = true; // write will emit 'end' if ended is true
-        stream.writable = false;
-        if (data !== undefined)
-            return queue_data(data, inputs);
-        else if (inputs === outputs) { // wait for processing 
-            stream.readable = false;
-            stream.emit('end');
-            stream.destroy();
-        }
+    catch (error) {
+        if (!ignore_error)
+            throw error;
     }
-    return stream;
 }
 export async function* stream_to_lines(stream) {
     let buf = '';
@@ -269,17 +165,6 @@ export class DecoderStream extends Transform {
         callback();
     }
 }
-/** 消费一个可读流 */
-export async function consume_stream(stream, ignore_error = false) {
-    try {
-        for await (const chunk of stream)
-            ;
-    }
-    catch (error) {
-        if (!ignore_error)
-            throw error;
-    }
-}
 /** 根据 range 生成整数序列 (iterable)
     - range: 取值为逗号分割的多个可用值或值区间 (不能含有空格)，比如：`8321,8322,8300-8310,11000-11999`
     - reverse?: `false` 在 range 内从后往前生成 */