ddan-js 2.5.4 → 2.5.6

package/bin/lib/modules/qs/index.js

@@ -9,55 +9,29 @@ const https = (url) => {
 };
 const RegHost = /^(http[s]?):\/\/([\w.]+)(?::(\d+))?/;
 const parseUrl = (url) => {
-    let host = '';
-    let origin = '';
-    // if (/^http[s]?:\/\/([\w.]+)/.test(url)) {
-    //   host = url.replace(/^http[s]?:\/\/([\w.]+)[\w\W]+/, '$1')
-    //   origin = url.replace(/^(http[s]?:\/\/)([\w.]+)[\w\W]+/, '$1$2')
-    // }
     const hostInfo = parseHost(url);
-    if (hostInfo) {
-        host = hostInfo.host;
-        origin = hostInfo.origin;
-    }
-    const arr = url.split('?');
-    const _path = arr[0];
-    const query = arr.length > 1 ? arr[1] : '';
-    let page = '';
-    const mat = _path.match(/[\/]?([\w\_\-]+)[.]?[\w]*[?]?$/);
-    if (mat) {
-        page = mat[1];
-    }
+    const { origin = '', url: _url = '', query = '' } = hostInfo;
+    const pathInfo = parsePath(_url);
     const params = (0, decode_1.default)(query, { multiple: true, uri: false });
-    const idx = _path.lastIndexOf('/') + 1;
-    const filename = _path.substring(idx);
-    const last = filename.lastIndexOf('.');
-    const filenameWithoutExtension = filename.substring(0, last);
-    const extension = filename.substring(last);
-    const root = _path.substring(0, idx);
-    return {
-        host,
-        origin,
-        url,
-        path: _path,
-        page,
-        query,
-        filename: filenameWithoutExtension ? filename : '',
-        filenameWithoutExtension,
-        extension: filenameWithoutExtension ? extension : '',
-        route: filenameWithoutExtension ? root : '',
+    const result = {
+        ...hostInfo,
+        ...pathInfo,
+        pathname: _url.substring(_url.indexOf(origin || '') + origin.length),
         params,
     };
+    return result;
 };
-const parsePath = (path) => {
-    const _path = (path || '').replace(/\\/g, '/').split('?')[0];
-    const idx = _path.lastIndexOf('/') + 1;
-    const name = _path.substring(idx);
+const parsePath = (url) => {
+    const _url = (url || '').replace(/\\/g, '/').split('?')[0];
+    const mat = _url.match(/[\/]?([\w\_\-]+)[.]?[\w]*[?]?$/);
+    const page = mat ? mat[1] : '';
+    const idx = _url.lastIndexOf('/') + 1;
+    const name = _url.substring(idx);
     const last = name.lastIndexOf('.');
-    const withoutExtension = name.substring(0, last);
-    const extension = name.substring(last);
-    const root = _path.substring(0, idx);
-    return { root, name, withoutExtension, extension };
+    const withoutExtension = name.substring(0, last) || '';
+    const extname = last >= 0 ? name.substring(last) : '';
+    const route = _url.substring(0, idx) || '';
+    return { route, page, name, withoutExtension, extname };
 };
 const join = (...args) => {
     const arr = [];
@@ -70,18 +44,28 @@ const join = (...args) => {
     return arr.join('/');
 };
 const parseHost = (url) => {
+    const result = {
+        href: url,
+        url: '',
+        origin: '',
+        protocol: '',
+        host: '',
+        port: '',
+        query: '',
+    };
     if (!url)
-        return undefined;
+        return result;
     const matches = url.match(RegHost);
     if (!matches || matches.length < 4)
-        return undefined;
+        return result;
     const port = matches[3] || '';
-    const result = {
-        origin: matches[0],
-        protocol: matches[1],
-        host: `${matches[2]}${port ? ':' + port : ''}`,
-        port,
-    };
+    const arr = url.split('?');
+    result.url = arr[0];
+    result.origin = matches[0];
+    result.protocol = `${matches[1]}:`;
+    result.host = `${matches[2]}${port ? ':' + port : ''}`;
+    result.port = port;
+    result.query = arr.length > 1 ? arr[1] : '';
     return result;
 };
 exports.default = { parse: decode_1.default, stringify: encode_1.default, https, parseUrl, parsePath, parseHost, join };

package/bin/lib/typings/index.js

@@ -1,12 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dd = exports.Ddan = void 0;
-var Ddan;
-(function (Ddan) {
-    ;
-    ;
-})(Ddan || (exports.Ddan = Ddan = {}));
-var dd;
-(function (dd) {
-    ;
-})(dd || (exports.dd = dd = {}));

package/bin/lib/util/function.js

@@ -16,6 +16,9 @@ function singleton() {
             }
             return Singleton.__instance__;
         }
+        static get I() {
+            return this.Instance;
+        }
     }
     return Singleton;
 }

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

@@ -1,6 +1,5 @@
 import Store from "./store";
 import LoopFrame from "../modules/time/frame";
-import DPipeline from "./pipeline";
 import DPipeparallel from "./pipeparallel";
 export interface ITriggerRecord {
     time: number;
@@ -46,7 +45,6 @@ export declare class Joker {
      * @returns
      */
     timesClean: (mode?: "storage" | "running") => void;
-    pipeline: () => DPipeline;
     parallel: () => DPipeparallel;
 }
 declare const joker: Joker;

package/bin/types/index.d.ts

@@ -11,6 +11,7 @@ declare const dUtil: {
         new (): {};
         __instance__: any;
         readonly Instance: T;
+        readonly I: T;
     };
     getset: <T_1 = any>(t?: T_1 | undefined) => import("./typings").Ddan.IGetset<T_1>;
     copy: (source: any, options?: {
@@ -186,12 +187,14 @@ declare const dUtil: {
 declare const dHook: {
     sleep: (ms?: number) => Promise<unknown>;
     run: <T = any>(task?: Function | Promise<T> | undefined, wait?: number) => Promise<[any, undefined] | [null, T]>;
-    exec: (func: Function, taskId?: string) => Promise<any[]>;
+    exec: (func: Function, taskId?: string) => Promise<[any, undefined] | [null, any]>;
     debounce: typeof import("./modules/hook/debounce").default;
     throttle: typeof import("./modules/hook/throttle").default;
     task: (param?: import("./typings").Ddan.Func1<any, any> | undefined) => import("./class/pipeTask").default;
     mutex: typeof import("./modules/hook/mutex").default;
     polling: typeof import("./modules/hook/polling").default;
+    pipe: (func: Function) => import("./modules/hook/modules/pipeline").default;
+    pipeline: () => import("./modules/hook/modules/pipeline").default;
     to: <T_1 = any, U extends object = any>(promise: Promise<T_1>, errorExt?: object | undefined) => Promise<[null, T_1] | [U, undefined]>;
     go: <T_2 = any>(task?: Function | Promise<T_2> | undefined) => Promise<[any, undefined] | [null, T_2]>;
     delay: (ms?: number) => Promise<unknown>;
@@ -252,25 +255,29 @@ declare const dMini: {
         }) => string;
         https: (url: string) => string;
         parseUrl: (url: string) => {
-            host: string;
-            origin: string;
-            url: string;
-            path: string;
+            pathname: string;
+            params: {};
+            route: string;
             page: string;
+            name: string;
+            withoutExtension: string;
+            extname: string;
+            href: string;
+            url: string;
+            origin: string;
+            host: string;
+            protocol: string;
+            port: string;
             query: string;
-            filename: string;
-            filenameWithoutExtension: string;
-            extension: string;
-            route: string;
-            params: {};
         };
-        parsePath: (path: string) => {
-            root: string;
+        parsePath: (url: string) => {
+            route: string;
+            page: string;
             name: string;
             withoutExtension: string;
-            extension: string;
+            extname: string;
         };
-        parseHost: (url: string) => import("./typings").Ddan.IHttpHost | undefined;
+        parseHost: (url: string) => import("./typings").Ddan.IHttpHost;
         join: (...args: string[]) => string;
     };
     icon: import("./class/icon").DIcon;
@@ -385,25 +392,29 @@ declare const dWeb: {
         }) => string;
         https: (url: string) => string;
         parseUrl: (url: string) => {
-            host: string;
-            origin: string;
-            url: string;
-            path: string;
+            pathname: string;
+            params: {};
+            route: string;
             page: string;
+            name: string;
+            withoutExtension: string;
+            extname: string;
+            href: string;
+            url: string;
+            origin: string;
+            host: string;
+            protocol: string;
+            port: string;
             query: string;
-            filename: string;
-            filenameWithoutExtension: string;
-            extension: string;
-            route: string;
-            params: {};
         };
-        parsePath: (path: string) => {
-            root: string;
+        parsePath: (url: string) => {
+            route: string;
+            page: string;
             name: string;
             withoutExtension: string;
-            extension: string;
+            extname: string;
         };
-        parseHost: (url: string) => import("./typings").Ddan.IHttpHost | undefined;
+        parseHost: (url: string) => import("./typings").Ddan.IHttpHost;
         join: (...args: string[]) => string;
     };
     icon: import("./class/icon").DIcon;
@@ -461,12 +472,14 @@ declare const _default: {
     hook: {
         sleep: (ms?: number) => Promise<unknown>;
         run: <T = any>(task?: Function | Promise<T> | undefined, wait?: number) => Promise<[any, undefined] | [null, T]>;
-        exec: (func: Function, taskId?: string) => Promise<any[]>;
+        exec: (func: Function, taskId?: string) => Promise<[any, undefined] | [null, any]>;
         debounce: typeof import("./modules/hook/debounce").default;
         throttle: typeof import("./modules/hook/throttle").default;
         task: (param?: import("./typings").Ddan.Func1<any, any> | undefined) => import("./class/pipeTask").default;
         mutex: typeof import("./modules/hook/mutex").default;
         polling: typeof import("./modules/hook/polling").default;
+        pipe: (func: Function) => import("./modules/hook/modules/pipeline").default;
+        pipeline: () => import("./modules/hook/modules/pipeline").default;
         to: <T_1 = any, U extends object = any>(promise: Promise<T_1>, errorExt?: object | undefined) => Promise<[null, T_1] | [U, undefined]>;
         go: <T_2 = any>(task?: Function | Promise<T_2> | undefined) => Promise<[any, undefined] | [null, T_2]>;
         delay: (ms?: number) => Promise<unknown>;
@@ -499,6 +512,7 @@ declare const _default: {
             new (): {};
             __instance__: any;
             readonly Instance: T_4;
+            readonly I: T_4;
         };
         getset: <T_5 = any>(t?: T_5 | undefined) => import("./typings").Ddan.IGetset<T_5>;
         copy: (source: any, options?: {
@@ -630,25 +644,29 @@ declare const _default: {
         }) => string;
         https: (url: string) => string;
         parseUrl: (url: string) => {
-            host: string;
-            origin: string;
-            url: string;
-            path: string;
+            pathname: string;
+            params: {};
+            route: string;
             page: string;
+            name: string;
+            withoutExtension: string;
+            extname: string;
+            href: string;
+            url: string;
+            origin: string;
+            host: string;
+            protocol: string;
+            port: string;
             query: string;
-            filename: string;
-            filenameWithoutExtension: string;
-            extension: string;
-            route: string;
-            params: {};
         };
-        parsePath: (path: string) => {
-            root: string;
+        parsePath: (url: string) => {
+            route: string;
+            page: string;
             name: string;
             withoutExtension: string;
-            extension: string;
+            extname: string;
         };
-        parseHost: (url: string) => import("./typings").Ddan.IHttpHost | undefined;
+        parseHost: (url: string) => import("./typings").Ddan.IHttpHost;
         join: (...args: string[]) => string;
     };
     css: {

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

@@ -0,0 +1,16 @@
+import DPipeline from './modules/pipeline';
+declare const DHooker_base: {
+    new (): {};
+    __instance__: any;
+    readonly Instance: DHooker;
+    readonly I: DHooker;
+};
+export default class DHooker extends DHooker_base {
+    __lockedMap: Map<string, Promise<[any, undefined] | [null, any]>>;
+    pipeline: DPipeline;
+    constructor();
+    lock(id: string, func: Function): Promise<[any, undefined] | [null, any]> | undefined;
+    unlock(id: string): void;
+    exec(func: Function, taskId: string): Promise<[any, undefined] | [null, any]>;
+}
+export {};

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

@@ -1,9 +1,10 @@
+import { Ddan } from '../../typings';
 import debounce from './debounce';
 import throttle from './throttle';
 import mutex from './mutex';
 import DPipeTask from '../../class/pipeTask';
-import { Ddan } from '../../typings';
 import polling from './polling';
+import DPipeline from './modules/pipeline';
 /**
  *
  * @param task 任务
@@ -14,12 +15,14 @@ declare function run<T = any>(task?: Promise<T> | Function, wait?: number): Prom
 declare const _default: {
     sleep: (ms?: number) => Promise<unknown>;
     run: typeof run;
-    exec: (func: Function, taskId?: string) => Promise<any[]>;
+    exec: (func: Function, taskId?: string) => Promise<[any, undefined] | [null, any]>;
     debounce: typeof debounce;
     throttle: typeof throttle;
     task: (param?: Ddan.Func1<any, any> | undefined) => DPipeTask;
     mutex: typeof mutex;
     polling: typeof polling;
+    pipe: (func: Function) => DPipeline;
+    pipeline: () => DPipeline;
     to: <T = any, U extends object = any>(promise: Promise<T>, errorExt?: object | undefined) => Promise<[null, T] | [U, undefined]>;
     go: <T_1 = any>(task?: Function | Promise<T_1> | undefined) => Promise<[any, undefined] | [null, T_1]>;
     delay: (ms?: number) => Promise<unknown>;

package/bin/types/{class → modules/hook/modules}/pipeline.d.ts

@@ -1,4 +1,5 @@
-export default class DPipeline {
+import { Ddan } from '../../../typings';
+export default class DPipeline implements Ddan.IPipeline {
     __list: any[];
     __running: boolean;
     __waitting: boolean;

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

@@ -1,4 +1,4 @@
-import { Ddan } from '../..';
+import { Ddan } from '../../typings';
 declare const _default: {
     parse: (qs: any, { sep, eq, max, multiple, uri, parseNumber, parseBoolean }?: {
         sep?: string | undefined;
@@ -20,25 +20,29 @@ declare const _default: {
     }) => string;
     https: (url: string) => string;
     parseUrl: (url: string) => {
-        host: string;
-        origin: string;
-        url: string;
-        path: string;
+        pathname: string;
+        params: {};
+        route: string;
         page: string;
+        name: string;
+        withoutExtension: string;
+        extname: string;
+        href: string;
+        url: string;
+        origin: string;
+        host: string;
+        protocol: string;
+        port: string;
         query: string;
-        filename: string;
-        filenameWithoutExtension: string;
-        extension: string;
-        route: string;
-        params: {};
     };
-    parsePath: (path: string) => {
-        root: string;
+    parsePath: (url: string) => {
+        route: string;
+        page: string;
         name: string;
         withoutExtension: string;
-        extension: string;
+        extname: string;
     };
-    parseHost: (url: string) => Ddan.IHttpHost | undefined;
+    parseHost: (url: string) => Ddan.IHttpHost;
     join: (...args: string[]) => string;
 };
 export default _default;

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

@@ -16,10 +16,13 @@ export declare namespace Ddan {
     type Func4<T0 = any, T1 = any, T2 = any, T3 = any, R = any> = Callback<[T0, T1, T2, T3], R>;
     type Result<T = any> = T | Promise<T>;
     interface IHttpHost {
+        href: string;
+        url: string;
         origin: string;
         host: string;
         protocol: string;
         port: string;
+        query: string;
     }
     interface IGetset<T> {
         set(value?: T): void;
@@ -119,7 +122,7 @@ export declare namespace Ddan {
     }
     interface IRegexRule {
         key: string;
-        flag?: "i" | "g" | "m" | "gi" | "mi";
+        flag?: 'i' | 'g' | 'm' | 'gi' | 'mi';
         value: string;
     }
     interface IIgnoreParams {
@@ -139,6 +142,12 @@ export declare namespace Ddan {
         maxWait?: number;
         trailing?: boolean;
     }
+    interface IPipeline {
+        pipe(func?: any): IPipeline;
+        delay(t?: number): IPipeline;
+        clear(): IPipeline;
+        whenAll(): Promise<IPipeline>;
+    }
 }
 export declare namespace dd {
     interface IHttpRequest {
@@ -162,7 +171,7 @@ export declare namespace dd {
         [key: string]: any;
         url: string;
         model?: string;
-        method: "get" | "post" | "put";
+        method: 'get' | 'post' | 'put';
         body?: string;
         plugins?: Record<string, any>;
     }
@@ -190,7 +199,7 @@ export declare namespace dd {
     interface IDWatermarkParams {
         [key: string]: any;
         t?: number;
-        g?: "nw" | "north" | "ne" | "west" | "center" | "east" | "sw" | "south" | "se";
+        g?: 'nw' | 'north' | 'ne' | 'west' | 'center' | 'east' | 'sw' | 'south' | 'se';
         x?: number;
         y?: number;
         voffset?: number;
@@ -199,7 +208,7 @@ export declare namespace dd {
         pady?: number;
     }
     interface IDWatermarkText {
-        type?: "d3F5LXplbmhlaQ" | "d3F5LW1pY3JvaGVp" | "ZmFuZ3poZW5nc2h1c29uZw" | "ZmFuZ3poZW5na2FpdGk" | "ZmFuZ3poZW5naGVpdGk" | "ZmFuZ3poZW5nZmFuZ3Nvbmc" | "ZHJvaWRzYW5zZmFsbGJhY2s";
+        type?: 'd3F5LXplbmhlaQ' | 'd3F5LW1pY3JvaGVp' | 'ZmFuZ3poZW5nc2h1c29uZw' | 'ZmFuZ3poZW5na2FpdGk' | 'ZmFuZ3poZW5naGVpdGk' | 'ZmFuZ3poZW5nZmFuZ3Nvbmc' | 'ZHJvaWRzYW5zZmFsbGJhY2s';
         color?: string;
         size?: number;
         shadow?: number;

package/bin/types/util/function.d.ts

@@ -7,6 +7,7 @@ declare function singleton<T>(): {
     new (): {};
     __instance__: any;
     readonly Instance: T;
+    readonly I: T;
 };
 declare function getset<T = any>(t?: T): Ddan.IGetset<T>;
 declare const _default: {

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

@@ -6,6 +6,7 @@ declare const _default: {
         new (): {};
         __instance__: any;
         readonly Instance: T;
+        readonly I: T;
     };
     getset: <T_1 = any>(t?: T_1 | undefined) => import("..").Ddan.IGetset<T_1>;
     copy: (source: any, options?: {

package/package.json

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

package/bin/lib/class/task.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const base_1 = require("../modules/hook/base");
-class DTask {
-    __source;
-    constructor(source) {
-        this.__source = source;
-    }
-    run = () => base_1.default.safeDo(this.__source);
-    static _lockedMap = new Map();
-    static _lock(id, func) {
-        if (!id || !func)
-            return undefined;
-        const task = new DTask(func).run();
-        this._lockedMap.set(id, task);
-        return task;
-    }
-    static _unlock(id) {
-        if (!id)
-            return;
-        this._lockedMap.delete(id);
-    }
-    static async exec(func, taskId) {
-        if (!func || !taskId) {
-            return new DTask(func).run();
-        }
-        const _task = this._lockedMap.get(taskId);
-        if (_task) {
-            return _task;
-        }
-        const _newTask = this._lock(taskId, func);
-        if (!_newTask)
-            return new DTask(func).run();
-        const result = await _newTask;
-        this._unlock(taskId);
-        return result;
-    }
-}
-exports.default = DTask;

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

@@ -1,9 +0,0 @@
-export default class DTask<T = any> {
-    __source: any;
-    constructor(source?: any);
-    run: () => Promise<[any, undefined] | [null, T]>;
-    static _lockedMap: Map<string, Promise<any[]>>;
-    static _lock(id: string, func: Function): Promise<[any, undefined] | [null, any]> | undefined;
-    static _unlock(id: string): void;
-    static exec(func: Function, taskId: string): Promise<any[]>;
-}