@certd/pipeline 1.21.2 → 1.22.0

package/dist/utils/util.shell.js

@@ -0,0 +1,136 @@
+//转换为import
+import os from "os";
+import childProcess from "child_process";
+import fixPath from "fix-path";
+import iconv from "iconv-lite";
+var _execFile = childProcess.execFile;
+import { logger } from "./util.log.js";
+fixPath();
+class SystemShell {
+    async exec(cmds, args = {}) {
+        throw new Error("You have to implement the method exec!");
+    }
+}
+class LinuxSystemShell extends SystemShell {
+    async exec(cmds, args = {}) {
+        if (typeof cmds === "string") {
+            cmds = [cmds];
+        }
+        for (const cmd of cmds) {
+            await _childExec(cmd, { shell: "/bin/bash" });
+        }
+    }
+}
+class DarwinSystemShell extends SystemShell {
+    async exec(cmds, args = {}) {
+        if (typeof cmds === "string") {
+            cmds = [cmds];
+        }
+        let ret;
+        for (const cmd of cmds) {
+            ret = await _childExec(cmd, args);
+        }
+        return ret;
+    }
+}
+class WindowsSystemShell extends SystemShell {
+    async exec(cmds, args = {}) {
+        if (typeof cmds === "string") {
+            cmds = [cmds];
+        }
+        let compose = 'echo  "test" '; // 'chcp 65001  '
+        for (const cmd of cmds) {
+            compose += " && " + cmd;
+        }
+        // compose += '&& exit'
+        const ret = await childExec(compose, args);
+        // log.info('cmd complete:', compose)
+        return ret;
+    }
+}
+function _childExec(composeCmds, options = {}) {
+    return new Promise((resolve, reject) => {
+        logger.info("shell:", composeCmds);
+        childProcess.exec(composeCmds, options, function (error, stdout, stderr) {
+            if (error) {
+                logger.error("cmd 命令执行错误：", composeCmds, stderr);
+                reject(new Error(stderr));
+            }
+            else {
+                // log.info('cmd 命令完成：', stdout)
+                resolve(stdout);
+            }
+            // log.info('关闭 cmd')
+            // ps.kill('SIGINT')
+        });
+    });
+}
+function childExec(composeCmds, args = {}) {
+    return new Promise((resolve, reject) => {
+        const encoding = "cp936";
+        const binaryEncoding = "binary";
+        logger.info("shell:", composeCmds);
+        childProcess.exec(composeCmds, { encoding: binaryEncoding, ...args }, function (error, stdout, stderr) {
+            if (error) {
+                // console.log('------', decoder.decode(stderr))
+                const message = iconv.decode(Buffer.from(stderr, binaryEncoding), encoding);
+                logger.error("cmd 命令执行错误：", composeCmds, message);
+                reject(new Error(message));
+            }
+            else {
+                // log.info('cmd 命令完成：', stdout)
+                const message = iconv.decode(Buffer.from(stdout, binaryEncoding), encoding);
+                resolve(message);
+            }
+            // log.info('关闭 cmd')
+            // ps.kill('SIGINT')
+        });
+    });
+}
+function getSystemShell() {
+    switch (getSystemPlatform()) {
+        case "mac":
+            return new DarwinSystemShell();
+        case "linux":
+            return new LinuxSystemShell();
+        case "windows":
+            return new WindowsSystemShell();
+        default:
+            throw new Error(`UNKNOWN OS TYPE ${os.platform()}`);
+    }
+}
+function getSystemPlatform() {
+    switch (os.platform()) {
+        case "darwin":
+            return "mac";
+        case "linux":
+            return "linux";
+        case "win32":
+            return "windows";
+        default:
+            throw new Error(`UNKNOWN OS TYPE ${os.platform()}`);
+    }
+}
+async function execute(cmd, args) {
+    return await getSystemShell().exec(cmd, args);
+}
+async function execFile(file, args, options) {
+    return new Promise((resolve, reject) => {
+        _execFile(file, args, options, (err, stdout) => {
+            if (err) {
+                logger.error("文件执行出错：", file, err);
+                reject(err);
+                return;
+            }
+            logger.debug("执行成功：", stdout);
+            resolve(stdout);
+        });
+    });
+}
+export const cmd = {
+    getSystemShell,
+    getSystemPlatform,
+    execute,
+    execFile,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/util.sleep.js

@@ -0,0 +1,8 @@
+export default function (timeout) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve({});
+        }, timeout);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5zbGVlcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy91dGlsLnNsZWVwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxPQUFPLFdBQVcsT0FBZTtJQUN0QyxPQUFPLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUU7UUFDN0IsVUFBVSxDQUFDLEdBQUcsRUFBRTtZQUNkLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUNkLENBQUMsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNkLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyJ9

package/dist/utils/util.sp.d.ts

@@ -0,0 +1,22 @@
+import { ILogger } from "./util.log.js";
+export type ExecOption = {
+    cmd: string | string[];
+    env: any;
+    logger?: ILogger;
+    options?: any;
+};
+declare function exec(opts: ExecOption): Promise<string>;
+export type SpawnOption = {
+    cmd: string | string[];
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+    env: any;
+    logger?: ILogger;
+    options?: any;
+};
+declare function spawn(opts: SpawnOption): Promise<string>;
+export declare const sp: {
+    spawn: typeof spawn;
+    exec: typeof exec;
+};
+export {};

package/dist/utils/util.sp.js

@@ -0,0 +1,91 @@
+//转换为import
+import childProcess from "child_process";
+import { safePromise } from "./util.promise.js";
+import { logger } from "./util.log.js";
+async function exec(opts) {
+    let cmd = "";
+    const log = opts.logger || logger;
+    if (opts.cmd instanceof Array) {
+        for (const item of opts.cmd) {
+            if (cmd) {
+                cmd += " && " + item;
+            }
+            else {
+                cmd = item;
+            }
+        }
+    }
+    log.info(`执行命令: ${cmd}`);
+    return safePromise((resolve, reject) => {
+        childProcess.exec(cmd, {
+            env: {
+                ...process.env,
+                ...opts.env,
+            },
+            ...opts.options,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                log.error(`exec error: ${error}`);
+                reject(error);
+            }
+            else {
+                const res = stdout.toString("utf-8");
+                log.info(`stdout: ${res}`);
+                resolve(res);
+            }
+        });
+    });
+}
+async function spawn(opts) {
+    let cmd = "";
+    const log = opts.logger || logger;
+    if (opts.cmd instanceof Array) {
+        for (const item of opts.cmd) {
+            if (cmd) {
+                cmd += " && " + item;
+            }
+            else {
+                cmd = item;
+            }
+        }
+    }
+    log.info(`执行命令: ${cmd}`);
+    let stdout = "";
+    let stderr = "";
+    return safePromise((resolve, reject) => {
+        const ls = childProcess.spawn(cmd, {
+            shell: process.platform == "win32",
+            env: {
+                ...process.env,
+                ...opts.env,
+            },
+            ...opts.options,
+        });
+        ls.stdout.on("data", (data) => {
+            log.info(`stdout: ${data}`);
+            stdout += data;
+        });
+        ls.stderr.on("data", (data) => {
+            log.error(`stderr: ${data}`);
+            stderr += data;
+        });
+        ls.on("error", (error) => {
+            log.error(`child process error: ${error}`);
+            reject(error);
+        });
+        ls.on("close", (code) => {
+            if (code !== 0) {
+                log.error(`child process exited with code ${code}`);
+                reject(new Error(stderr));
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}
+export const sp = {
+    spawn,
+    exec,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/fix-esm-import-paths.js

@@ -0,0 +1,96 @@
+import * as fs from "fs";
+import * as path from "path";
+
+// https://gist.github.com/lovasoa/8691344
+async function* walk(dir) {
+  for await (const d of await fs.promises.opendir(dir)) {
+    const entry = path.join(dir, d.name);
+    if (d.isDirectory()) {
+      yield* walk(entry);
+    } else if (d.isFile()) {
+      yield entry;
+    }
+  }
+}
+
+function resolveImportPath(sourceFile, importPath, options) {
+  const sourceFileAbs = path.resolve(process.cwd(), sourceFile);
+  const root = path.dirname(sourceFileAbs);
+  const { moduleFilter = defaultModuleFilter } = options;
+
+  if (moduleFilter(importPath)) {
+    const importPathAbs = path.resolve(root, importPath);
+    let possiblePath = [path.resolve(importPathAbs, "./index.ts"), path.resolve(importPathAbs, "./index.js"), importPathAbs + ".ts", importPathAbs + ".js"];
+
+    if (possiblePath.length) {
+      for (let i = 0; i < possiblePath.length; i++) {
+        let entry = possiblePath[i];
+        if (fs.existsSync(entry)) {
+          const resolved = path.relative(root, entry.replace(/\.ts$/, ".js"));
+
+          if (!resolved.startsWith(".")) {
+            return "./" + resolved;
+          }
+
+          return resolved;
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+function replace(filePath, outFilePath, options) {
+  const code = fs.readFileSync(filePath).toString();
+  const newCode = code.replace(/(import|export) (.+?) from ('[^\n']+'|"[^\n"]+");/gs, function (found, action, imported, from) {
+    const importPath = from.slice(1, -1);
+    let resolvedPath = resolveImportPath(filePath, importPath, options);
+
+    if (resolvedPath) {
+      resolvedPath = resolvedPath.replaceAll("\\", "/");
+      console.log("\t", importPath, resolvedPath);
+      return `${action} ${imported} from "${resolvedPath}";`;
+    }
+
+    return found;
+  });
+
+  if (code !== newCode) {
+    fs.writeFileSync(outFilePath, newCode);
+  }
+}
+
+// Then, use it with a simple async for loop
+async function run(srcDir, options = defaultOptions) {
+  const { sourceFileFilter = defaultSourceFileFilter } = options;
+
+  for await (const entry of walk(srcDir)) {
+    if (sourceFileFilter(entry)) {
+      console.log(entry);
+      replace(entry, entry, options);
+    }
+  }
+}
+
+const defaultSourceFileFilter = function (sourceFilePath) {
+  return /\.(js|ts)$/.test(sourceFilePath) && !/node_modules/.test(sourceFilePath);
+};
+
+const defaultModuleFilter = function (importedModule) {
+  return !path.isAbsolute(importedModule) && !importedModule.startsWith("@") && !importedModule.endsWith(".js");
+};
+
+const defaultOptions = {
+  sourceFileFilter: defaultSourceFileFilter,
+  moduleFilter: defaultModuleFilter,
+};
+
+// Switch this to test on one file or directly run on a directory.
+const DEBUG = false;
+
+if (DEBUG) {
+  replace("./src/index.ts", "./out.ts", defaultOptions);
+} else {
+  await run("./src/", defaultOptions);
+}

package/package.json

@@ -1,44 +1,46 @@
 {
   "name": "@certd/pipeline",
   "private": false,
-  "version": "1.21.2",
-  "main": "./dist/bundle.js",
-  "module": "./dist/bundle.mjs",
-  "types": "./dist/d/index.d.ts",
+  "version": "1.22.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "scripts": {
     "dev": "vite",
-    "build": "rollup -c",
+    "build": "tsc --skipLibCheck",
+    "build3": "rollup -c",
     "build2": "vue-tsc --noEmit && vite build",
     "preview": "vite preview"
   },
   "dependencies": {
-    "axios": "^1.4.0",
+    "@types/lodash-es": "^4.17.12",
+    "axios": "^1.7.2",
+    "fix-path": "^4.0.0",
+    "lodash-es": "^4.17.21",
     "node-forge": "^1.3.1",
     "nodemailer": "^6.9.3",
     "qs": "^6.11.2"
   },
   "devDependencies": {
-    "@certd/acme-client": "^1.21.2",
     "@rollup/plugin-commonjs": "^23.0.4",
     "@rollup/plugin-json": "^6.0.0",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-terser": "^0.4.3",
     "@rollup/plugin-typescript": "^11.0.0",
-    "@types/chai": "^4.3.5",
-    "@types/lodash": "^4.14.194",
+    "@types/chai": "^4.3.10",
     "@types/mocha": "^10.0.1",
     "@types/node-forge": "^1.3.2",
     "@types/uuid": "^9.0.2",
     "@typescript-eslint/eslint-plugin": "^5.59.7",
     "@typescript-eslint/parser": "^5.59.7",
-    "chai": "^4.3.7",
+    "chai": "4.3.10",
     "dayjs": "^1.11.7",
     "eslint": "^8.41.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^4.2.1",
-    "lodash": "^4.17.21",
+    "iconv-lite": "^0.6.3",
     "log4js": "^6.9.1",
     "mocha": "^10.2.0",
     "prettier": "^2.8.8",
@@ -47,10 +49,11 @@
     "rollup-plugin-typescript2": "^0.34.1",
     "rollup-plugin-visualizer": "^5.8.2",
     "ts-node": "^10.9.1",
+    "tsc-esm-fix": "^3.0.0",
     "tslib": "^2.5.2",
     "typescript": "^5.0.4",
     "vite": "^4.3.8",
     "vue-tsc": "^1.6.5"
   },
-  "gitHead": "031df8fc35f60650d509b448efe1124e06ac7553"
+  "gitHead": "47fe3d5826661f678d081ab53e67c847a3239d88"
 }

package/tsconfig.json

@@ -1,23 +1,41 @@
 {
+  "compileOnSave": true,
   "compilerOptions": {
-    "importHelpers": false,
     "target": "ESNext",
-    "useDefineForClassFields": true,
     "module": "ESNext",
-    "moduleResolution": "Node",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "inlineSourceMap":true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "stripInternal": true,
+    "skipLibCheck": true,
+    "pretty": true,
+    "declaration": true,
+    "forceConsistentCasingInFileNames": true,
+    "typeRoots": [ "./typings", "./node_modules/@types"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": true,
+    "useDefineForClassFields": true,
     "strict": true,
-    "jsx": "preserve",
-    "sourceMap": true,
+//    "sourceMap": true,
     "resolveJsonModule": true,
-    "isolatedModules": true,
-    "esModuleInterop": true,
+    "isolatedModules": false,
     "lib": ["ESNext", "DOM"],
-    "skipLibCheck": true,
-    "experimentalDecorators": true,
-    "paths": {
-      "tslib" : ["./node_modules/tslib/tslib.d.ts"]
-    }
   },
-
-  "include": ["src/**/*.ts", "src/**/*.d.ts", "src/**/*.tsx", "src/**/*.vue","test/**/*.ts","rollup.config.ts"],
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.d.ts",
+    "src/**/*.json"
+  ],
+  "exclude": [
+    "*.js",
+    "*.ts",
+    "dist",
+    "node_modules",
+    "test"
+  ],
 }