@jayfong/x-utils 1.0.0-202407012223

package/data_set.js

@@ -0,0 +1,85 @@
+import { asyncExitHook } from "exit-hook";
+import fs from "fs-extra";
+import * as path from "node:path";
+import { keyBy, keysStrict, pickStrict } from "vtils";
+import { v } from "vtils/vae";
+import { XCsv } from "./csv.js";
+import { XJson } from "./json.js";
+import { XYaml } from "./yaml.js";
+class XDataSet {
+  constructor(options) {
+    this.options = options;
+    this.storeType = options.storeFile.endsWith(".csv") ? "csv" : options.storeFile.endsWith(".yaml") || options.storeFile.endsWith(".yml") ? "yaml" : "json";
+    this.dataShapeSchema = options.dataSchema(v);
+    this.dataSchema = v.object(this.dataShapeSchema);
+    this.csvOptions = {
+      arrayDelimiter: options.csvArrayDelimiter,
+      arrayFieldNames: keysStrict(this.dataShapeSchema).filter(
+        (key) => this.dataShapeSchema[key].options.type === "array"
+      ),
+      objectFieldNames: keysStrict(this.dataShapeSchema).filter(
+        (key) => this.dataShapeSchema[key].options.type === "object"
+      ),
+      booleanFieldNames: keysStrict(this.dataShapeSchema).filter(
+        (key) => this.dataShapeSchema[key].options.type === "boolean"
+      ),
+      dateFieldNames: keysStrict(this.dataShapeSchema).filter(
+        (key) => this.dataShapeSchema[key].options.type === "date"
+      )
+    };
+    if (!options.noAutoWrite) {
+      const timer = setInterval(() => {
+        this.write();
+      }, options.autoWriteInterval || 5e3);
+      asyncExitHook(
+        async () => {
+          clearInterval(timer);
+          await this.write();
+        },
+        {
+          wait: 1e4
+        }
+      );
+    }
+  }
+  storeType;
+  dataShapeSchema;
+  dataSchema;
+  csvOptions;
+  currentMap;
+  get current() {
+    const orderedDataFieldNames = keysStrict(this.dataShapeSchema);
+    const dataSet = keysStrict(this.currentMap).map((dataKeyValue) => {
+      const data = {
+        ...this.currentMap[dataKeyValue],
+        [this.options.dataKey]: dataKeyValue
+      };
+      return this.dataSchema.cast(
+        pickStrict(data, orderedDataFieldNames)
+      );
+    });
+    return dataSet;
+  }
+  async read() {
+    let dataSet = [];
+    try {
+      dataSet = await (this.storeType === "csv" ? XCsv.read(this.options.storeFile, this.csvOptions) : this.storeType === "yaml" ? XYaml.read(this.options.storeFile) : XJson.read(this.options.storeFile));
+    } catch {
+    }
+    dataSet = dataSet.map((data) => this.dataSchema.cast(data));
+    this.currentMap = keyBy(
+      dataSet,
+      (data) => data[this.options.dataKey]
+    );
+    return dataSet;
+  }
+  async write(dataSet = this.current) {
+    console.log(`\u{1F4A5} \u5199\u5165 ${this.options.storeFile}`);
+    await fs.ensureDir(path.dirname(this.options.storeFile));
+    await (this.storeType === "csv" ? XCsv.write(this.options.storeFile, dataSet, this.csvOptions) : this.storeType === "yaml" ? XYaml.write(this.options.storeFile, dataSet) : XJson.write(this.options.storeFile, dataSet));
+    console.log(`\u2705 \u5199\u5165 ${this.options.storeFile}`);
+  }
+}
+export {
+  XDataSet
+};

package/env.d.ts

@@ -0,0 +1,4 @@
+export declare class XEnv {
+    private static getEnvVarsFromFile;
+    static getEnvVar<T>(name: string): Promise<T | undefined>;
+}

package/env.js

@@ -0,0 +1,32 @@
+import dotenv from "dotenv";
+import { isPlainObject, memoize } from "vtils";
+import { XFs } from "./fs.js";
+import { XPath } from "./path.js";
+import { XYaml } from "./yaml.js";
+class XEnv {
+  static getEnvVarsFromFile = memoize(async () => {
+    const envYmlFile = XPath.join(import.meta.dirname, ".env.yml");
+    if (await XFs.pathExists(envYmlFile)) {
+      return XYaml.read(envYmlFile);
+    }
+    const envYamlFile = XPath.join(import.meta.dirname, ".env.yaml");
+    if (await XFs.pathExists(envYamlFile)) {
+      return XYaml.read(envYamlFile);
+    }
+    const dotenvFile = XPath.join(import.meta.dirname, ".env");
+    if (await XFs.pathExists(dotenvFile)) {
+      const dotenvContent = await XFs.readFile(dotenvFile, "utf-8");
+      return dotenv.parse(dotenvContent);
+    }
+  });
+  static async getEnvVar(name) {
+    if (process.env[name] != null) {
+      return process.env[name];
+    }
+    const envVars = await XEnv.getEnvVarsFromFile();
+    return isPlainObject(envVars) ? envVars[name] ?? void 0 : void 0;
+  }
+}
+export {
+  XEnv
+};

package/fs.d.ts

@@ -0,0 +1,2 @@
+import fs from 'fs-extra';
+export declare const XFs: typeof fs;

package/fs.js

@@ -0,0 +1,5 @@
+import fs from "fs-extra";
+const XFs = fs;
+export {
+  XFs
+};

package/html.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { ParagraphChild } from 'docx';
+export { HTMLElement as XHtmlElement, NodeType as XHtmlNodeType, } from 'node-html-parser';
+export declare class XHtml {
+    static parse(html: string): import("node-html-parser").HTMLElement;
+    static toDocxParagraphChildren(html: string, fetchImage: (url: string) => Promise<Buffer>): Promise<ParagraphChild[]>;
+}

package/html.js

@@ -0,0 +1,45 @@
+import { ImageRun, TextRun } from "docx";
+import { imageDimensionsFromData } from "image-dimensions";
+import { parse } from "node-html-parser";
+import { parser } from "posthtml-parser";
+import { flattenDeep, ii } from "vtils";
+import {
+  HTMLElement,
+  NodeType
+} from "node-html-parser";
+class XHtml {
+  static parse(html) {
+    return parse(html);
+  }
+  static async toDocxParagraphChildren(html, fetchImage) {
+    const nodes = parser(html, {
+      decodeEntities: true
+    }).map(function process(node) {
+      return typeof node === "object" && node.content && Array.isArray(node.content) ? flattenDeep(node.content).map(process).flat() : [node];
+    }).flat();
+    return await Promise.all(
+      nodes.map(async (node) => {
+        return typeof node === "string" || typeof node === "number" ? new TextRun({
+          text: String(node)
+        }) : node.tag === "img" && typeof node.attrs?.src === "string" ? await ii(async () => {
+          const imageBuffer = await fetchImage(node.attrs.src);
+          const size = imageDimensionsFromData(imageBuffer);
+          return new ImageRun({
+            data: imageBuffer,
+            transformation: {
+              width: size?.width || 0,
+              height: size?.height || 0
+            }
+          });
+        }) : new TextRun({
+          text: ""
+        });
+      })
+    );
+  }
+}
+export {
+  XHtml,
+  HTMLElement as XHtmlElement,
+  NodeType as XHtmlNodeType
+};

package/http_server.d.ts

@@ -0,0 +1,10 @@
+export type XHttpServerOptions = {
+    port: number;
+    handlers: Record<string, (data: any) => any>;
+};
+export declare class XHttpServer {
+    private options;
+    constructor(options: XHttpServerOptions);
+    start(): Promise<void>;
+    static start(options: XHttpServerOptions): Promise<void>;
+}

package/http_server.js

@@ -0,0 +1,26 @@
+import cors from "@fastify/cors";
+import Fastify from "fastify";
+class XHttpServer {
+  constructor(options) {
+    this.options = options;
+  }
+  async start() {
+    const fastify = Fastify({
+      logger: true
+    });
+    await fastify.register(cors);
+    Object.keys(this.options.handlers).forEach((name) => {
+      fastify.post(`/${name}`, (req) => this.options.handlers[name](req.body));
+    });
+    await fastify.listen({
+      host: "0.0.0.0",
+      port: this.options.port
+    });
+  }
+  static async start(options) {
+    await new XHttpServer(options).start();
+  }
+}
+export {
+  XHttpServer
+};

package/json.d.ts

@@ -0,0 +1,6 @@
+export declare class XJson {
+    static parse<T>(value: string): T;
+    static stringify(value: any, compact?: boolean): string;
+    static read<T>(file: string): Promise<T>;
+    static write(file: string, value: any, compact?: boolean): Promise<void>;
+}

package/json.js

@@ -0,0 +1,19 @@
+import * as fs from "node:fs";
+class XJson {
+  static parse(value) {
+    return JSON.parse(value);
+  }
+  static stringify(value, compact = false) {
+    return JSON.stringify(value, null, compact ? void 0 : 2);
+  }
+  static async read(file) {
+    const value = await fs.promises.readFile(file, "utf8");
+    return XJson.parse(value);
+  }
+  static async write(file, value, compact = false) {
+    await fs.promises.writeFile(file, XJson.stringify(value, compact));
+  }
+}
+export {
+  XJson
+};

package/ksb.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="lodash" />
+export declare class XKsb {
+    static request<T>(url: string, data?: any): Promise<T>;
+    static desensitize(text: string): string;
+    static getPaperId(payload: {
+        paperName: string;
+    }): Promise<string | undefined>;
+    static getPaperIdMemo: ((payload: {
+        paperName: string;
+    }) => Promise<string | undefined>) & import("lodash").MemoizedFunction;
+    static deletePaper(payload: {
+        paperName: string;
+    }): Promise<void>;
+    static addPaper(payload: {
+        paperName: string;
+    }): Promise<void>;
+    static ensurePaperExistsAndEmpty(payload: {
+        paperName: string;
+    }): Promise<void>;
+    static addQuestion(payload: {
+        paperName: string;
+        question: {
+            type: '单选' | '判断' | '填空' | '问答';
+            question: string;
+            options: Array<{
+                key: string;
+                value: string;
+            }>;
+            answer: string | boolean | string[];
+        };
+    }): Promise<void>;
+}

package/ksb.js

@@ -0,0 +1,197 @@
+import { xr } from "@jayfong/x-request";
+import { castArray, md5, memoize } from "vtils";
+class XKsb {
+  static request(url, data) {
+    const token = "%22ZpWKMcjeUIsZMwZIMUdkhEfAq93e3dPsQyWxAtkRNbc=%22";
+    const key = "12b6bb84e093532fb72b4d65fec3f00b";
+    const clientId = "ca37dd67-f885-4678-91a7-6531bb153ef2";
+    const ts = (/* @__PURE__ */ new Date()).getTime();
+    const sign = md5(`${key}${clientId}${url}${ts}${key}`);
+    return xr.postJson({
+      url: `https://www.kaoshibao.com/api${url}`,
+      data,
+      autoReferer: true,
+      // proxyUrl: 'http://127.0.0.1:8888',
+      headers: {
+        Timestamp: ts,
+        Version: "2.2.2",
+        Platform: "web",
+        Authorization: token,
+        "Client-Identifier": clientId,
+        Sign: sign
+      }
+    }).then((res) => res.data);
+  }
+  static desensitize(text) {
+    return text.replace(/台湾|澳门|香港|西藏|新疆|习近平/g, (word) => {
+      return word.split("").join(String.fromCharCode(8290));
+    });
+  }
+  static async getPaperId(payload) {
+    const res = await XKsb.request("/user/paper/list", {
+      keyword: payload.paperName,
+      page: 1,
+      size: 10,
+      parentid: "",
+      column: "0",
+      direction: ""
+    });
+    return res.data.rows?.[0]?.paperid;
+  }
+  static getPaperIdMemo = memoize(
+    (payload) => XKsb.getPaperId(payload),
+    (payload) => payload.paperName
+  );
+  static async deletePaper(payload) {
+    const paperId = await XKsb.getPaperId(payload);
+    if (paperId) {
+      await XKsb.request("/user/paper/delete", {
+        id: paperId
+      });
+      XKsb.getPaperIdMemo.cache.delete(payload.paperName);
+    }
+  }
+  static async addPaper(payload) {
+    await XKsb.request("/user/paper/add", {
+      name: payload.paperName,
+      type: "4"
+    });
+    XKsb.getPaperIdMemo.cache.delete(payload.paperName);
+  }
+  static async ensurePaperExistsAndEmpty(payload) {
+    await XKsb.deletePaper(payload);
+    await XKsb.addPaper(payload);
+  }
+  static async addQuestion(payload) {
+    payload.question.question = XKsb.desensitize(payload.question.question);
+    payload.question.options.forEach((opt) => {
+      opt.value = XKsb.desensitize(opt.value);
+    });
+    if (typeof payload.question.answer === "string") {
+      payload.question.answer = XKsb.desensitize(payload.question.answer);
+    } else if (Array.isArray(payload.question.answer)) {
+      payload.question.answer.forEach((v, i) => {
+        if (typeof v === "string") {
+          payload.question.answer[i] = XKsb.desensitize(v);
+        }
+      });
+    }
+    const paperId = await XKsb.getPaperIdMemo(payload);
+    await XKsb.request(
+      "/user/question/add",
+      // 单选
+      payload.question.type === "\u5355\u9009" ? {
+        id: "",
+        qtype: "1",
+        paperid: paperId,
+        options: JSON.stringify(
+          payload.question.options.map((opt) => ({
+            Key: opt.key,
+            Value: opt.value,
+            checked: false,
+            extend: ""
+          }))
+        ),
+        judgeOptions: [
+          { Key: "A", Value: "\u6B63\u786E" },
+          { Key: "B", Value: "\u9519\u8BEF" }
+        ],
+        question: payload.question.question,
+        answer: payload.question.answer,
+        extra: '{"ordered":"0","case_sensitive":"0"}',
+        paixuAnswer: "",
+        analysis: "",
+        parentid: 0,
+        chapter: "",
+        difficulty: "",
+        blanks: [{ Value: "" }],
+        optionData: [],
+        optionTipic: [],
+        optionDataTipic: {
+          options: [
+            { Key: "A", Value: "", checked: false },
+            { Key: "B", Value: "", checked: false },
+            { Key: "C", Value: "", checked: false },
+            { Key: "D", Value: "", checked: false }
+          ],
+          answer: ""
+        },
+        fileList: []
+      } : payload.question.type === "\u5224\u65AD" ? {
+        id: "",
+        qtype: "3",
+        paperid: paperId,
+        options: '[{"Key":"A","Value":"","checked":false},{"Key":"B","Value":"","checked":false},{"Key":"C","Value":"","checked":false},{"Key":"D","Value":"","checked":false}]',
+        judgeOptions: [
+          { Key: "A", Value: "\u6B63\u786E" },
+          { Key: "B", Value: "\u9519\u8BEF" }
+        ],
+        question: payload.question.question,
+        answer: payload.question.answer ? "A" : "B",
+        parentid: 0,
+        chapter: "",
+        difficulty: "",
+        extra: '{"ordered":"0","case_sensitive":"0"}',
+        analysis: "",
+        paixuAnswer: "",
+        blanks: [{ Value: "" }],
+        optionData: [],
+        optionTipic: [],
+        optionDataTipic: ""
+      } : payload.question.type === "\u586B\u7A7A" ? {
+        id: "",
+        qtype: "4",
+        paperid: paperId,
+        options: '[{"Key":"A","Value":"","checked":false},{"Key":"B","Value":"","checked":false},{"Key":"C","Value":"","checked":false},{"Key":"D","Value":"","checked":false}]',
+        judgeOptions: [
+          { Key: "A", Value: "\u6B63\u786E" },
+          { Key: "B", Value: "\u9519\u8BEF" }
+        ],
+        question: payload.question.question,
+        answer: castArray(payload.question.answer).join("|"),
+        parentid: 0,
+        chapter: "",
+        difficulty: "",
+        extra: '{"ordered":"0","case_sensitive":"0"}',
+        analysis: "",
+        paixuAnswer: "",
+        blanks: castArray(payload.question.answer).map((v) => ({
+          Value: v
+        })),
+        optionData: [],
+        optionTipic: [],
+        optionDataTipic: ""
+      } : payload.question.type === "\u95EE\u7B54" ? {
+        id: "",
+        qtype: "11",
+        paperid: paperId,
+        options: '[{"Key":"A","Value":"","checked":false},{"Key":"B","Value":"","checked":false},{"Key":"C","Value":"","checked":false},{"Key":"D","Value":"","checked":false}]',
+        judgeOptions: [
+          { Key: "A", Value: "\u6B63\u786E" },
+          { Key: "B", Value: "\u9519\u8BEF" }
+        ],
+        question: payload.question.question,
+        answer: payload.question.answer,
+        parentid: 0,
+        chapter: "",
+        difficulty: "",
+        extra: '{"ordered":"0","case_sensitive":"0"}',
+        analysis: "",
+        paixuAnswer: "",
+        blanks: [{ Value: "" }],
+        optionData: [],
+        optionTipic: [],
+        optionDataTipic: ""
+      } : {}
+      // 判断
+      // {"id":"","qtype":"3","paperid":"15844653","options":"[{\"Key\":\"A\",\"Value\":\"\",\"checked\":false},{\"Key\":\"B\",\"Value\":\"\",\"checked\":false},{\"Key\":\"C\",\"Value\":\"\",\"checked\":false},{\"Key\":\"D\",\"Value\":\"\",\"checked\":false}]","judgeOptions":[{"Key":"A","Value":"正确"},{"Key":"B","Value":"错误"}],"question":"<p>顶顶顶顶</p>","answer":"A","parentid":0,"chapter":"","difficulty":"","extra":"{\"ordered\":\"0\",\"case_sensitive\":\"0\"}","analysis":"","paixuAnswer":"","blanks":[{"Value":""}],"optionData":[],"optionTipic":[],"optionDataTipic":""}
+      // 填空
+      // {"id":"","qtype":"4","paperid":"15844653","options":"[{\"Key\":\"A\",\"Value\":\"\",\"checked\":false},{\"Key\":\"B\",\"Value\":\"\",\"checked\":false},{\"Key\":\"C\",\"Value\":\"\",\"checked\":false},{\"Key\":\"D\",\"Value\":\"\",\"checked\":false}]","judgeOptions":[{"Key":"A","Value":"正确"},{"Key":"B","Value":"错误"}],"question":"<p>99999999</p>","answer":"999|888","parentid":0,"chapter":"","difficulty":"","extra":"{\"ordered\":\"0\",\"case_sensitive\":\"0\"}","analysis":"","paixuAnswer":"","blanks":[{"Value":"999"},{"Value":"888"}],"optionData":[],"optionTipic":[],"optionDataTipic":""}
+      // 问答
+      // {"id":"","qtype":"11","paperid":"15844653","options":"[{\"Key\":\"A\",\"Value\":\"\",\"checked\":false},{\"Key\":\"B\",\"Value\":\"\",\"checked\":false},{\"Key\":\"C\",\"Value\":\"\",\"checked\":false},{\"Key\":\"D\",\"Value\":\"\",\"checked\":false}]","judgeOptions":[{"Key":"A","Value":"正确"},{"Key":"B","Value":"错误"}],"question":"<p>666666</p>","answer":"<p>67777777</p>","parentid":0,"chapter":"","difficulty":"","extra":"{\"ordered\":\"0\",\"case_sensitive\":\"0\"}","analysis":"","paixuAnswer":"","blanks":[{"Value":""}],"optionData":[],"optionTipic":[],"optionDataTipic":""}
+    );
+  }
+}
+export {
+  XKsb
+};

package/number.d.ts

@@ -0,0 +1,3 @@
+export declare class XNumber {
+    static toChinese(value: number): string;
+}

package/number.js

@@ -0,0 +1,9 @@
+import nzh from "nzh";
+class XNumber {
+  static toChinese(value) {
+    return nzh.cn.encodeS(value);
+  }
+}
+export {
+  XNumber
+};

package/ocr.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+export declare class XOcr {
+    static recognize(url: string, { serverUrl, }?: {
+        serverUrl?: string;
+    }): Promise<string>;
+    static recognizeCaptcha(buffer: Buffer, { serverUrl, serverToken, }?: {
+        serverUrl?: string;
+        serverToken?: string;
+    }): Promise<string>;
+}

package/ocr.js

@@ -0,0 +1,54 @@
+import { xr } from "@jayfong/x-request";
+import { XEnv } from "./env.js";
+class XOcr {
+  static async recognize(url, {
+    serverUrl
+  } = {}) {
+    if (serverUrl == null) {
+      serverUrl = await XEnv.getEnvVar("X_OCR_RECOGNIZE_SERVER_URL");
+    }
+    const { data: buffer } = await xr.get({
+      url,
+      autoReferer: true
+    });
+    const base64 = buffer.toString("base64");
+    const { data: res } = await xr.postJson({
+      url: serverUrl,
+      data: {
+        base64,
+        options: {}
+      }
+    });
+    if (res.code !== 100) {
+      if (res.data.includes("No text found in image")) {
+        return "";
+      }
+      throw new Error(res.data);
+    }
+    return res.data.map((item) => item.text).join(" ");
+  }
+  static async recognizeCaptcha(buffer, {
+    serverUrl,
+    serverToken
+  } = {}) {
+    if (serverUrl == null) {
+      serverUrl = await XEnv.getEnvVar("X_OCR_RECOGNIZE_CAPTCHA_SERVER_URL");
+    }
+    if (serverToken == null) {
+      serverToken = await XEnv.getEnvVar(
+        "X_OCR_RECOGNIZE_CAPTCHA_SERVER_TOKEN"
+      );
+    }
+    const res = await xr.postJson({
+      url: serverUrl,
+      data: xr.formData({
+        token: serverToken,
+        file: xr.formFile(buffer, { name: "xx.png" })
+      })
+    });
+    return res.data.text;
+  }
+}
+export {
+  XOcr
+};

package/ofd.d.ts

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