@maiyunnet/kebab 2.0.4 → 2.0.6

package/lib/text.d.ts

@@ -0,0 +1,40 @@
+import * as types from '../types';
+export declare function sizeFormat(size: number, spliter?: string): string;
+export declare function parseUrl(url: string): types.IUrlParse;
+export declare function urlResolve(from: string, to: string): string;
+export declare function urlAtom(url: string): string;
+export declare const REGEXP_EMAIL: RegExp;
+export declare function isEMail(email: string): boolean;
+export declare const REGEXP_IPV4: RegExp;
+export declare function isIPv4(ip: string): boolean;
+export declare const REGEXP_IPV6: RegExp;
+export declare function isIPv6(ip: string): boolean;
+export declare const REGEXP_DOMAIN: RegExp;
+export declare function isDomain(domain: string): boolean;
+export declare const REGEXP_ASCII: RegExp;
+export declare function isAscii(text: string): boolean;
+export declare function nlReplace(str: string, to?: string): string;
+export interface IDomain {
+    tld: string | null;
+    sld: string | null;
+    domain: string | null;
+    sub: string | null;
+}
+export declare function parseDomain(domain: string): Promise<IDomain>;
+export declare function match(str: string, regs: RegExp[]): boolean;
+export declare function isPhoneCN(p: string): boolean;
+export declare function isIdCardCN(idcard: string): boolean;
+export declare function queryStringify(query: Record<string, any>, encode?: boolean): string;
+export declare function queryParse(query: string): Record<string, string | string[]>;
+export declare function htmlescape(html: string): string;
+export declare function isRealPath(path: string): boolean;
+export declare function getFilename(path: string): string;
+export declare function stringifyResult(rtn: types.Json): string;
+export declare function parseJson(str: string): any;
+export declare function stringifyJson(obj: types.Json, space?: string | number): string;
+type TFalsy = false | '' | 0 | null | undefined | typeof NaN;
+export declare function isFalsy(val: any): val is TFalsy;
+export declare function logicalOr<T, T2>(v1: T, v2: T2): [T] extends [TFalsy] ? T2 : T;
+export declare function str2int(str: string, digits?: number): number;
+export declare function int2str(int: number, digits?: number, decimal?: number): string;
+export {};

package/lib/text.js

@@ -60,7 +60,7 @@ exports.isFalsy = isFalsy;
 exports.logicalOr = logicalOr;
 exports.str2int = str2int;
 exports.int2str = int2str;
-const kebab = __importStar(require("~/index"));
+const kebab = __importStar(require("../index"));
 const fs = __importStar(require("./fs"));
 function sizeFormat(size, spliter = ' ') {
     const units = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];

package/lib/time.d.ts

@@ -0,0 +1,22 @@
+import * as sCtr from '../sys/ctr';
+export interface IOptions {
+    'zone'?: number;
+    'data'?: string | number;
+}
+export declare const HOUR = 3600;
+export declare const DAY = 86400;
+export declare const YEAR = 31536000;
+export declare class Time {
+    private readonly _date;
+    private _zone;
+    constructor(ctr: sCtr.Ctr, opt: IOptions);
+    setZone(zone: number): void;
+    getZone(): number;
+    toUTCString(): string;
+    format(f: string, zone?: number): string;
+    stamp(): number;
+}
+export declare function get(ctr: sCtr.Ctr, opt?: IOptions): Time;
+export declare function stamp(date?: Date | string, zone?: number | sCtr.Ctr | null): number;
+export declare function isMs(time: number): boolean;
+export declare function format(zone: number | sCtr.Ctr | null, f: string, date?: Date | number): string;

package/lib/time.js

@@ -38,7 +38,7 @@ exports.get = get;
 exports.stamp = stamp;
 exports.isMs = isMs;
 exports.format = format;
-const sCtr = __importStar(require("~/sys/ctr"));
+const sCtr = __importStar(require("../sys/ctr"));
 exports.HOUR = 3600;
 exports.DAY = 86400;
 exports.YEAR = 31536000;

package/lib/ws.d.ts

@@ -0,0 +1,87 @@
+import * as http from 'http';
+import * as net from 'net';
+import * as types from '../types';
+import * as sCtr from '../sys/ctr';
+export declare enum EFrameReceiveMode {
+    STANDARD = 0,
+    LITE = 1,
+    SIMPLE = 2
+}
+export declare enum EOpcode {
+    CONTINUATION = 0,
+    TEXT = 1,
+    BINARY = 2,
+    CLOSE = 8,
+    PING = 9,
+    PONG = 10
+}
+export interface IConnectOptions {
+    'timeout'?: number;
+    'hosts'?: Record<string, string>;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'cookie'?: Record<string, types.ICookie>;
+    'mode'?: EFrameReceiveMode;
+    'masking'?: boolean;
+    'mproxy'?: {
+        'url': string;
+        'auth': string;
+    };
+}
+export interface IMproxyOptions {
+    'timeout'?: number;
+    'hosts'?: Record<string, string>;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'mode'?: EFrameReceiveMode;
+    'masking'?: boolean;
+}
+export interface IRproxyOptions {
+    'timeout'?: number;
+    'hosts'?: Record<string, string>;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'mode'?: EFrameReceiveMode;
+    'masking'?: boolean;
+    'mproxy'?: {
+        'url': string;
+        'auth': string;
+    };
+}
+export declare class Socket {
+    private _ws;
+    constructor(request?: http.IncomingMessage, socket?: net.Socket, options?: {
+        'headers'?: http.OutgoingHttpHeaders;
+        'timeout'?: number;
+    });
+    connect(u: string, opt?: IConnectOptions): Promise<this | null>;
+    private _bindEvent;
+    private readonly _waitMsg;
+    private _error;
+    private _close;
+    private _on;
+    on(event: 'message', cb: (msg: {
+        'opcode': EOpcode;
+        'data': Buffer | string;
+    }) => void | Promise<void>): this;
+    on(event: 'error', cb: (error: any) => void | Promise<void>): this;
+    on(event: 'drain' | 'close' | 'end', cb: () => void | Promise<void>): this;
+    end(): void;
+    destroy(): void;
+    writeText(data: string): boolean;
+    writeResult(data: types.Json): boolean;
+    writeBinary(data: string | Buffer | Array<string | Buffer>): boolean;
+    get writable(): boolean;
+    get ended(): boolean;
+    get finished(): boolean;
+    get isServer(): boolean;
+    ping(data?: Buffer | string): boolean;
+    pong(data?: Buffer | string): boolean;
+}
+export declare function connect(u: string, opt?: IConnectOptions): Promise<Socket | null>;
+export declare function createServer(request: http.IncomingMessage, socket: net.Socket, options?: {
+    'headers'?: http.OutgoingHttpHeaders;
+    'timeout'?: number;
+}): Socket;
+export declare function mproxy(ctr: sCtr.Ctr, auth: string, opt?: IMproxyOptions): Promise<number>;
+export declare function rproxy(ctr: sCtr.Ctr, url: string, opt?: IRproxyOptions): Promise<boolean>;

package/lib/ws.js

@@ -39,8 +39,8 @@ exports.createServer = createServer;
 exports.mproxy = mproxy;
 exports.rproxy = rproxy;
 const liws = __importStar(require("@litert/websocket"));
-const lText = __importStar(require("~/lib/text"));
-const lNet = __importStar(require("~/lib/net"));
+const lText = __importStar(require("../lib/text"));
+const lNet = __importStar(require("../lib/net"));
 var EFrameReceiveMode;
 (function (EFrameReceiveMode) {
     EFrameReceiveMode[EFrameReceiveMode["STANDARD"] = 0] = "STANDARD";

package/lib/zip.d.ts

@@ -0,0 +1,40 @@
+import jszip from 'jszip';
+import * as types from '../types';
+export declare class Zip {
+    private readonly _zip;
+    private _path;
+    constructor(zip: jszip);
+    getContent(path: string): Promise<string | null>;
+    getContent<T extends types.TZipOutputType>(path: string, type: T): Promise<types.IZipOutputByType[T] | null>;
+    putContent<T extends types.TZipInputType>(path: string, data: types.IZipInputByType[T], options?: {
+        'base64'?: boolean;
+        'binary'?: boolean;
+        'date'?: Date;
+    }): void;
+    unlink(path: string): void;
+    stats(path: string): types.IZipStats | null;
+    isDir(path: string): types.IZipStats | false;
+    isFile(path: string): types.IZipStats | false;
+    readDir(path?: string, opt?: {
+        'hasChildren'?: boolean;
+        'hasDir'?: boolean;
+        'pathAsKey'?: false;
+    }): types.IZipItem[];
+    readDir(path?: string, opt?: {
+        'hasChildren'?: boolean;
+        'hasDir'?: boolean;
+        'pathAsKey': true;
+    }): Record<string, types.IZipItem>;
+    private _readDir;
+    private _list;
+    private _refreshList;
+    pwd(): string;
+    cd(dir: string): string;
+    generate<T extends types.TZipOutputType>(options?: {
+        'type'?: T;
+        'level'?: number;
+        'onUpdate'?: (percent: number, currentFile: string | null) => void;
+    }): Promise<types.IZipOutputByType[T]>;
+    getList(): Promise<Record<string, Buffer | string>>;
+}
+export declare function get(data?: types.TZipInputFileFormat): Promise<Zip | null>;

package/lib/zip.js

@@ -40,7 +40,7 @@ exports.Zip = void 0;
 exports.get = get;
 const jszip_1 = __importDefault(require("jszip"));
 const mime = __importStar(require("@litert/mime"));
-const lText = __importStar(require("~/lib/text"));
+const lText = __importStar(require("../lib/text"));
 class Zip {
     constructor(zip) {
         this._path = '/';

package/lib/zlib.d.ts

@@ -0,0 +1,25 @@
+import * as zlib from 'zlib';
+export interface ICompress {
+    readonly type: string;
+    readonly compress: zlib.Deflate | zlib.Gzip | zlib.BrotliCompress | zlib.Inflate | zlib.Gunzip | zlib.BrotliDecompress;
+}
+export interface ICompressBuffer {
+    readonly type: string;
+    readonly buffer: Buffer;
+}
+export declare function createGzip(options?: zlib.ZlibOptions): zlib.Gzip;
+export declare function createGunzip(): zlib.Gunzip;
+export declare function createDeflate(options?: zlib.ZlibOptions): zlib.Deflate;
+export declare function createInflate(): zlib.Inflate;
+export declare function createBrotliCompress(options?: zlib.ZlibOptions): zlib.BrotliCompress;
+export declare function createBrotliDecompress(): zlib.BrotliDecompress;
+export declare function createCompress(types: string, options?: zlib.ZlibOptions): ICompress | null;
+export declare function createDecompress(types: string): ICompress | null;
+export declare function gzip(buffer: zlib.InputType, options?: zlib.ZlibOptions): Promise<Buffer | null>;
+export declare function gunzip(buffer: zlib.InputType): Promise<Buffer | null>;
+export declare function deflate(buffer: zlib.InputType, options?: zlib.ZlibOptions): Promise<Buffer | null>;
+export declare function inflate(buffer: zlib.InputType): Promise<Buffer | null>;
+export declare function brotliCompress(buffer: zlib.InputType, options?: zlib.ZlibOptions): Promise<Buffer | null>;
+export declare function brotliDecompress(buffer: zlib.InputType): Promise<Buffer | null>;
+export declare function compress(types: string, buffer: zlib.InputType | null, options?: zlib.ZlibOptions): Promise<ICompressBuffer | null>;
+export declare function decompress(types: string, buffer: zlib.InputType | null): Promise<ICompressBuffer | null>;

package/main.d.ts

@@ -0,0 +1 @@
+import 'ts-alias-loader';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maiyunnet/kebab",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "Simple, easy-to-use, and fully-featured Node.js framework that is ready-to-use out of the box.",
   "keywords": [
     "kebab",
@@ -24,14 +24,14 @@
     "jszip": "^3.10.1",
     "mysql2": "^3.14.1",
     "ssh2": "^1.16.0",
-    "svg-captcha": "^1.4.0",
-    "ts-alias-loader": "^0.1.5"
+    "svg-captcha": "^1.4.0"
   },
   "devDependencies": {
     "@litert/eslint-plugin-rules": "^0.3.1",
     "@types/ejs": "^3.1.5",
     "@types/node": "^24.0.0",
     "@types/ssh2": "^1.15.5",
+    "tsc-alias": "^1.8.16",
     "typescript": "^5.8.3"
   }
 }

package/sys/child.d.ts

@@ -0,0 +1 @@
+export {};

package/sys/child.js

@@ -37,12 +37,12 @@ const http2 = __importStar(require("http2"));
 const tls = __importStar(require("tls"));
 const http = __importStar(require("http"));
 const crypto = __importStar(require("crypto"));
-const fs = __importStar(require("~/lib/fs"));
-const lCore = __importStar(require("~/lib/core"));
-const lText = __importStar(require("~/lib/text"));
-const sCtr = __importStar(require("~/sys/ctr"));
-const kebab = __importStar(require("~/index"));
-const sRoute = __importStar(require("~/sys/route"));
+const fs = __importStar(require("../lib/fs"));
+const lCore = __importStar(require("../lib/core"));
+const lText = __importStar(require("../lib/text"));
+const sCtr = __importStar(require("../sys/ctr"));
+const kebab = __importStar(require("../index"));
+const sRoute = __importStar(require("../sys/route"));
 const hbTimer = setInterval(function () {
     if (!process.connected || !process.send) {
         return;

package/sys/cmd.d.ts

@@ -0,0 +1 @@
+export {};

package/sys/cmd.js

@@ -34,12 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const http = __importStar(require("http"));
-const lFs = __importStar(require("~/lib/fs"));
-const lText = __importStar(require("~/lib/text"));
-const lTime = __importStar(require("~/lib/time"));
-const lCore = __importStar(require("~/lib/core"));
-const lCrypto = __importStar(require("~/lib/crypto"));
-const kebab = __importStar(require("~/index"));
+const lFs = __importStar(require("../lib/fs"));
+const lText = __importStar(require("../lib/text"));
+const lTime = __importStar(require("../lib/time"));
+const lCore = __importStar(require("../lib/core"));
+const lCrypto = __importStar(require("../lib/crypto"));
+const kebab = __importStar(require("../index"));
 const cmds = process.argv.slice(2);
 async function initDir(paths) {
     for (const path of paths) {

package/sys/ctr.d.ts

@@ -0,0 +1,96 @@
+import * as http from 'http';
+import * as http2 from 'http2';
+import * as session from '../lib/session';
+import * as db from '../lib/db';
+import * as kv from '../lib/kv';
+import * as lWs from '../lib/ws';
+import * as types from '../types';
+export declare function clearLocaleData(): void;
+export declare class Ctr {
+    protected _param: string[];
+    protected _action: string;
+    protected _headers: http.IncomingHttpHeaders;
+    protected _get: Record<string, string>;
+    protected _rawPost: Record<string, types.Json>;
+    protected _post: Record<string, types.Json>;
+    protected _input: string;
+    protected _files: Record<string, types.IPostFile | types.IPostFile[]>;
+    protected _cookie: Record<string, string>;
+    protected _jwt: Record<string, types.Json>;
+    protected _session: Record<string, types.Json>;
+    protected _sess: session.Session | null;
+    protected _cacheTTL: number;
+    protected _xsrf: string;
+    protected _httpCode: number;
+    protected _locale: string;
+    protected readonly _config: types.IConfig;
+    protected readonly _req: http2.Http2ServerRequest | http.IncomingMessage;
+    protected readonly _res: http2.Http2ServerResponse | http.ServerResponse;
+    protected readonly _socket: lWs.Socket;
+    protected _localeFiles: string[];
+    protected _localeData: Record<string, Record<string, string>>;
+    constructor(config: types.IConfig, req: http2.Http2ServerRequest | http.IncomingMessage, res?: http2.Http2ServerResponse | http.ServerResponse);
+    get isAvail(): boolean;
+    protected _timer?: {
+        'timer': NodeJS.Timeout;
+        'timeout': number;
+        'callback': () => void;
+    };
+    get timeout(): number;
+    set timeout(num: number);
+    private readonly _waitInfo;
+    protected _asyncTask(func: () => void | Promise<void>): void;
+    getPrototype(name: '_config'): types.IConfig;
+    getPrototype(name: '_sess'): session.Session | null;
+    getPrototype(name: '_headers'): http.IncomingHttpHeaders;
+    getPrototype(name: '_req'): http2.Http2ServerRequest | http.IncomingMessage;
+    getPrototype(name: '_res'): http2.Http2ServerResponse | http.ServerResponse;
+    getPrototype(name: '_socket'): lWs.Socket;
+    getPrototype(name: '_rawPost' | '_post' | '_get' | '_session'): Record<string, types.Json>;
+    getPrototype(name: '_input'): string;
+    getPrototype(name: string): types.Json;
+    setPrototype(name: string, val: string | string[] | http.IncomingHttpHeaders | Record<string, types.Json> | session.Session | lWs.Socket | null): void;
+    onLoad(): boolean | string | types.DbValue[] | Promise<boolean | string | types.DbValue[]>;
+    onUnload(rtn: boolean | string | types.DbValue[]): boolean | string | types.DbValue[] | Promise<boolean | string | types.DbValue[]>;
+    onUpgrade(): {
+        'headers'?: http.OutgoingHttpHeaders;
+        'timeout'?: number;
+    };
+    onData(data: Buffer | string, opcode: lWs.EOpcode): types.Json;
+    onMessage(data: Buffer | string, opcode: lWs.EOpcode): undefined | boolean | Promise<undefined | boolean>;
+    onDrain(): void | Promise<void>;
+    onClose(): void | Promise<void>;
+    protected _getRunTime(ms?: boolean): number;
+    protected _getMemoryUsage(): number;
+    protected _loadView(path: string, data?: types.Json): Promise<string>;
+    protected _checkInput(input: Record<string, types.Json>, rule: Record<string, types.Json[]>, rtn: types.Json[]): boolean;
+    protected _checkXInput(input: Record<string, types.Json>, rule: Record<string, types.Json[]>, rtn: types.Json[]): boolean;
+    protected _enabledXsrf(): void;
+    protected _getBasicAuth(user: string, pwd: string): string;
+    protected _device(): 'android' | 'windows' | 'linux' | 'macintosh' | 'ipad' | 'unknown';
+    private _authorization;
+    getAuthorization(): {
+        'user': string;
+        'pwd': string;
+    } | false | string;
+    protected _loadData(path: string): Promise<Record<string, string> | null>;
+    protected _location(location: string): false;
+    protected _startSession(link: db.Pool | kv.Pool, auth?: boolean, opt?: session.IOptions): Promise<void>;
+    protected _loadLocale(loc: string, pkg?: string): Promise<boolean>;
+    private _loadLocaleDeep;
+    protected _getLocaleJsonString(): string;
+    protected _getLocale(): string;
+    protected _cross(): boolean;
+    _l(key: string, data?: string[]): string;
+    protected _writeText(data: string): boolean;
+    protected _writeResult(data: types.Json): boolean;
+    protected _writeBinary(data: Buffer | string | Array<Buffer | string>): boolean;
+    protected _ping(): boolean;
+    protected _pong(): boolean;
+    protected _end(): void;
+    protected _handleFormData(events?: {
+        onfilestart?: (name: string) => boolean | undefined;
+        onfiledata?: (chunk: Buffer) => void;
+        onfileend?: () => void;
+    }): Promise<boolean>;
+}

package/sys/master.d.ts

@@ -0,0 +1 @@
+export {};

package/sys/master.js

@@ -36,14 +36,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const os = __importStar(require("os"));
 const cluster = __importStar(require("cluster"));
 const http = __importStar(require("http"));
-const kebab = __importStar(require("~/index"));
-const sRoute = __importStar(require("~/sys/route"));
-const lCore = __importStar(require("~/lib/core"));
-const lFs = __importStar(require("~/lib/fs"));
-const lText = __importStar(require("~/lib/text"));
-const lCrypto = __importStar(require("~/lib/crypto"));
-const lTime = __importStar(require("~/lib/time"));
-const lZip = __importStar(require("~/lib/zip"));
+const kebab = __importStar(require("../index"));
+const sRoute = __importStar(require("../sys/route"));
+const lCore = __importStar(require("../lib/core"));
+const lFs = __importStar(require("../lib/fs"));
+const lText = __importStar(require("../lib/text"));
+const lCrypto = __importStar(require("../lib/crypto"));
+const lTime = __importStar(require("../lib/time"));
+const lZip = __importStar(require("../lib/zip"));
 const workerList = {};
 async function run() {
     const configContent = await lFs.getContent(kebab.CONF_CWD + 'config.json', 'utf8');