@easbot/utils 0.2.10 → 0.2.11

package/dist/index.d.ts

@@ -1,13 +1,12 @@
 import { ChildProcess } from 'node:child_process';
 import z, { z as z$1 } from 'zod';
-export { z } from 'zod';
 import { statSync } from 'node:fs';
 import * as stream from 'stream';
 import { Readable } from 'stream';
 import * as _hono_node_ws from '@hono/node-ws';
 export { createNodeWebSocket } from '@hono/node-ws';
 import * as fs from 'fs';
-import { Context as Context$1, Next, Hono } from 'hono';
+import { Hono, Context as Context$1, Next } from 'hono';
 export { Hono, Next } from 'hono';
 import { ServerType } from '@hono/node-server';
 import { cors } from 'hono/cors';
@@ -111,6 +110,20 @@ declare namespace Shell {
     function platformShells(): string[];
     function isValid(file: string): boolean;
     function version(file: string): Promise<string | undefined>;
+    interface InstallOptions {
+        cwd?: string;
+        env?: Record<string, string | undefined>;
+        timeout?: number;
+        windowsHide?: boolean;
+    }
+    class InstallFailedError extends Error {
+        message: string;
+        pkg: string;
+        version: string;
+        originalError?: string | undefined;
+        constructor(message: string, pkg: string, version: string, originalError?: string | undefined);
+    }
+    function install(pkg: string, version?: string, installPath?: string): Promise<string>;
     interface RunOptions {
         cwd?: string;
         env?: Record<string, string | undefined>;
@@ -124,12 +137,12 @@ declare namespace Shell {
         stderr?: 'pipe' | 'inherit' | 'null';
         stdin?: 'pipe' | 'inherit' | 'null';
     }
-    function run(shell: string, command: string, options?: RunOptions): Promise<{
+    function run(shell: string | undefined, command: string, options?: RunOptions): Promise<{
         code: number;
         stdout: string;
         stderr: string;
     }>;
-    function spawn(shell: string, command: string, options?: SpawnOptions): {
+    function spawn(shell: string | undefined, command: string, options?: SpawnOptions): {
         stdout: any;
         stderr: any;
         stdin: any;
@@ -137,7 +150,29 @@ declare namespace Shell {
         exited: Promise<number>;
         kill: (signal?: string | number) => boolean;
     };
+    interface DollarRunOptions {
+        cwd?: string;
+        quiet?: boolean;
+        nothrow?: boolean;
+        env?: Record<string, string | undefined>;
+    }
+    function $(strings: TemplateStringsArray, ...values: unknown[]): {
+        quiet: () => any;
+        nothrow: () => any;
+        cwd: (dir: string) => any;
+        env: (env: Record<string, string | undefined>) => any;
+        text: () => Promise<string>;
+        lines: () => Promise<string[]>;
+        then: (onfulfilled: (result: {
+            exitCode: number;
+            stdout: Uint8Array;
+            stderr: Uint8Array;
+            text: () => string;
+            lines: () => string[];
+        }) => void, onrejected?: (error: Error) => void) => Promise<void>;
+    };
 }
+declare const $: typeof Shell.$;
 
 declare function formatLocalISO(date: Date | number, includeMilliseconds?: boolean): string;
 declare function formatLocalISOCompact(date: Date | number): string;
@@ -875,6 +910,11 @@ interface NodeSpawnResult {
     exitCode?: number;
 }
 declare namespace PKG {
+    type PackageManager = 'npm' | 'pnpm' | 'bun';
+    function packageManager(preferred?: PackageManager): Promise<{
+        name: PackageManager;
+        path: string;
+    } | undefined>;
     function which(command?: string, options?: NodeWhichOptions): Promise<string | null>;
     function whichSync(command?: string, options?: NodeWhichOptions): string | null;
     function clearWhichCache(): void;
@@ -926,21 +966,6 @@ declare namespace PKG {
         stdout: string;
         stderr: string;
     }>;
-    function $(strings: TemplateStringsArray, ...values: unknown[]): {
-        quiet: () => any;
-        nothrow: () => any;
-        cwd: (dir: string) => any;
-        env: (env: Record<string, string | undefined>) => any;
-        text: () => Promise<string>;
-        lines: () => Promise<string[]>;
-        then: (onfulfilled: (result: {
-            exitCode: number;
-            stdout: Uint8Array;
-            stderr: Uint8Array;
-            text: () => string;
-            lines: () => string[];
-        }) => void, onrejected?: (error: Error) => void) => Promise<void>;
-    };
     function readableStreamToText(stream: ReadableStream<Uint8Array>): Promise<string>;
     function nodeReadableStreamToText(stream: NodeJS.ReadableStream): Promise<string>;
     function xxHash32(str: string, seed?: number): number;
@@ -964,257 +989,6 @@ declare namespace PKG {
         }): Generator<string>;
         match(filepath: string): boolean;
     }
-    const InstallFailedError: {
-        new (data: {
-            message: string;
-            pkg: string;
-            version: string;
-            originalError?: string | undefined;
-        }, options?: ErrorOptions): {
-            readonly name: "PKGInstallFailedError";
-            readonly data: {
-                message: string;
-                pkg: string;
-                version: string;
-                originalError?: string | undefined;
-            };
-            schema(): z.ZodObject<{
-                name: z.ZodLiteral<"PKGInstallFailedError">;
-                data: z.ZodObject<{
-                    message: z.ZodString;
-                    pkg: z.ZodString;
-                    version: z.ZodString;
-                    originalError: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>;
-            }, z.core.$strip>;
-            toObject(): {
-                name: "PKGInstallFailedError";
-                data: {
-                    message: string;
-                    pkg: string;
-                    version: string;
-                    originalError?: string | undefined;
-                };
-            };
-            message: string;
-            stack?: string;
-            cause?: unknown;
-        };
-        readonly Schema: z.ZodObject<{
-            name: z.ZodLiteral<"PKGInstallFailedError">;
-            data: z.ZodObject<{
-                message: z.ZodString;
-                pkg: z.ZodString;
-                version: z.ZodString;
-                originalError: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>;
-        }, z.core.$strip>;
-        isInstance(input: any): input is {
-            readonly name: "PKGInstallFailedError";
-            readonly data: {
-                message: string;
-                pkg: string;
-                version: string;
-                originalError?: string | undefined;
-            };
-            schema(): z.ZodObject<{
-                name: z.ZodLiteral<"PKGInstallFailedError">;
-                data: z.ZodObject<{
-                    message: z.ZodString;
-                    pkg: z.ZodString;
-                    version: z.ZodString;
-                    originalError: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>;
-            }, z.core.$strip>;
-            toObject(): {
-                name: "PKGInstallFailedError";
-                data: {
-                    message: string;
-                    pkg: string;
-                    version: string;
-                    originalError?: string | undefined;
-                };
-            };
-            message: string;
-            stack?: string;
-            cause?: unknown;
-        };
-        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
-            new (data: z.input<Data>, options?: ErrorOptions): {
-                readonly name: Name;
-                readonly data: z.core.input<Data>;
-                schema(): z.ZodObject<{
-                    name: z.ZodLiteral<Name>;
-                    data: Data;
-                }, z.core.$strip>;
-                toObject(): {
-                    name: Name;
-                    data: z.core.input<Data>;
-                };
-                message: string;
-                stack?: string;
-                cause?: unknown;
-            };
-            readonly Schema: z.ZodObject<{
-                name: z.ZodLiteral<Name>;
-                data: Data;
-            }, z.core.$strip>;
-            isInstance(input: any): input is InstanceType<any>;
-            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
-            readonly Unknown: {
-                new (data: {
-                    message: string;
-                }, options?: ErrorOptions): {
-                    readonly name: "UnknownError";
-                    readonly data: {
-                        message: string;
-                    };
-                    schema(): z.ZodObject<{
-                        name: z.ZodLiteral<"UnknownError">;
-                        data: z.ZodObject<{
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                    toObject(): {
-                        name: "UnknownError";
-                        data: {
-                            message: string;
-                        };
-                    };
-                    message: string;
-                    stack?: string;
-                    cause?: unknown;
-                };
-                readonly Schema: z.ZodObject<{
-                    name: z.ZodLiteral<"UnknownError">;
-                    data: z.ZodObject<{
-                        message: z.ZodString;
-                    }, z.core.$strip>;
-                }, z.core.$strip>;
-                isInstance(input: any): input is {
-                    readonly name: "UnknownError";
-                    readonly data: {
-                        message: string;
-                    };
-                    schema(): z.ZodObject<{
-                        name: z.ZodLiteral<"UnknownError">;
-                        data: z.ZodObject<{
-                            message: z.ZodString;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                    toObject(): {
-                        name: "UnknownError";
-                        data: {
-                            message: string;
-                        };
-                    };
-                    message: string;
-                    stack?: string;
-                    cause?: unknown;
-                };
-                create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
-                readonly Unknown: any;
-                isError(error: unknown): error is Error;
-                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-                stackTraceLimit: number;
-            };
-            isError(error: unknown): error is Error;
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-            stackTraceLimit: number;
-        };
-        readonly Unknown: {
-            new (data: {
-                message: string;
-            }, options?: ErrorOptions): {
-                readonly name: "UnknownError";
-                readonly data: {
-                    message: string;
-                };
-                schema(): z.ZodObject<{
-                    name: z.ZodLiteral<"UnknownError">;
-                    data: z.ZodObject<{
-                        message: z.ZodString;
-                    }, z.core.$strip>;
-                }, z.core.$strip>;
-                toObject(): {
-                    name: "UnknownError";
-                    data: {
-                        message: string;
-                    };
-                };
-                message: string;
-                stack?: string;
-                cause?: unknown;
-            };
-            readonly Schema: z.ZodObject<{
-                name: z.ZodLiteral<"UnknownError">;
-                data: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
-            }, z.core.$strip>;
-            isInstance(input: any): input is {
-                readonly name: "UnknownError";
-                readonly data: {
-                    message: string;
-                };
-                schema(): z.ZodObject<{
-                    name: z.ZodLiteral<"UnknownError">;
-                    data: z.ZodObject<{
-                        message: z.ZodString;
-                    }, z.core.$strip>;
-                }, z.core.$strip>;
-                toObject(): {
-                    name: "UnknownError";
-                    data: {
-                        message: string;
-                    };
-                };
-                message: string;
-                stack?: string;
-                cause?: unknown;
-            };
-            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
-                new (data: z.input<Data>, options?: ErrorOptions): {
-                    readonly name: Name;
-                    readonly data: z.core.input<Data>;
-                    schema(): z.ZodObject<{
-                        name: z.ZodLiteral<Name>;
-                        data: Data;
-                    }, z.core.$strip>;
-                    toObject(): {
-                        name: Name;
-                        data: z.core.input<Data>;
-                    };
-                    message: string;
-                    stack?: string;
-                    cause?: unknown;
-                };
-                readonly Schema: z.ZodObject<{
-                    name: z.ZodLiteral<Name>;
-                    data: Data;
-                }, z.core.$strip>;
-                isInstance(input: any): input is InstanceType<any>;
-                create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
-                readonly Unknown: any;
-                isError(error: unknown): error is Error;
-                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-                stackTraceLimit: number;
-            };
-            readonly Unknown: any;
-            isError(error: unknown): error is Error;
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-            stackTraceLimit: number;
-        };
-        isError(error: unknown): error is Error;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-        stackTraceLimit: number;
-    };
-    function install(pkg: string, version?: string, installPath?: string): Promise<string>;
     const stdin: NodeJS.ReadStream & {
         fd: 0;
     };
@@ -1237,7 +1011,6 @@ declare namespace PKG {
     const streamingServer: typeof createStreamingServer;
     const webSocketServer: typeof createWebSocketServer;
 }
-declare const $: typeof PKG.$;
 declare const readableStreamToText: typeof PKG.readableStreamToText;
 declare const whichSync: typeof PKG.whichSync;