web-core-tcm 0.0.25 → 0.0.26

package/dist/src/api/patient/alova/implement/meta.js

@@ -0,0 +1,404 @@
+import { Meta as E, TongueMeta as I, FaceMeta as G, SceneMeta as R, PulsationMeta as q, PPGMeta as B, PCGMeta as k, ECGMeta as D, AppendixMeta as F, ComplaintMeta as L, Metas as T, MetaType as n } from "../../meta.js";
+import { Tag as W, Annotation as H } from "../../core.js";
+import { tongueAnalyze as J, faceAnalyze as K } from "../../../algorithm/inspectionsAlgorithm.js";
+import { base64ToArrayBuffer as x } from "../../../../util/image.js";
+import { pulsationAnalysis as Q, pulsationPreprocessing as U } from "../../../algorithm/pulsationsAlgorithm.js";
+import { analysisLisems as z } from "../../../algorithm/lisemsAlgorithm.js";
+class V extends E {
+  deserialize() {
+    return Promise.resolve(this);
+  }
+  inject() {
+    return Promise.resolve(this);
+  }
+  serialize() {
+    return new ArrayBuffer(0);
+  }
+  getObject() {
+    return Promise.resolve("");
+  }
+  async get() {
+    return this.of(await c(this.id));
+  }
+  async put() {
+    return this.of(await l(this.id, this.type, this.state()));
+  }
+  post() {
+    throw new Error("Method not implemented.");
+  }
+  async delete() {
+    return await u(this.id), this;
+  }
+  analyze() {
+    throw new Error("Method not implemented.");
+  }
+  static queryMetaWithPatient(t, e, a, o, h, d, w, y, r, i, m, P, C) {
+    const b = C?.map((g) => g.state()), A = a?.state();
+    return patientApi.metaStateRestful.queryMetaAndPatientState({
+      data: {
+        ...A && { ownerState: A },
+        ...o && { type: o },
+        page: t,
+        pageSize: e,
+        ...h && { startTime: h },
+        ...d && { endTime: d },
+        ...w && { sort: w },
+        ...y && { patientName: y },
+        ...r && { patientPhoneNumber: r },
+        ...i && { patientStartBirthdate: i },
+        ...m && { patientEndBirthdate: m },
+        ...P && { patientGender: P },
+        ...b && { tagsState: b }
+      },
+      async transform(g) {
+        const S = [];
+        for (const O of g.content)
+          S.push(await M.map(O));
+        return {
+          data: S,
+          total: g.totalElements,
+          page: g.number,
+          pageSize: g.size,
+          pageCount: g.totalPages,
+          isLastPage: g.last
+        };
+      }
+    }).send();
+  }
+  static query(t, e, a, o, h, d, w) {
+    const y = a?.state();
+    return patientApi.metaStateRestful.queryMetaState({
+      data: {
+        ...y && { ownerState: y },
+        ...o && { type: o },
+        ...h && { startTime: h },
+        ...d && { endTime: d },
+        ...w && { sort: w },
+        page: t,
+        pageSize: e
+      },
+      async transform(r) {
+        const i = [];
+        for (const m of r.content)
+          i.push(await M.map(m));
+        return {
+          data: i,
+          total: r.totalElements,
+          page: r.number,
+          pageSize: r.size,
+          pageCount: r.totalPages,
+          isLastPage: r.last
+        };
+      }
+    }).send();
+  }
+  static queryMetaStateByExactMatch(t, e, a, o, h, d, w, y) {
+    const r = e?.map((i) => i.state());
+    return patientApi.metaStateRestful.queryMetaStateByExactMatch({
+      data: {
+        ...t && { id: t },
+        ...r && { ownerState: r },
+        ...a && { type: a },
+        ...o && { pageSize: o },
+        ...h && { page: h },
+        ...d && { startTime: d },
+        ...w && { endTime: w },
+        ...y && { sort: y }
+      },
+      async transform(i) {
+        const m = [];
+        for (const P of i.content)
+          m.push(await M.map(P));
+        return {
+          data: m,
+          total: i.totalElements,
+          page: i.number,
+          pageSize: i.size,
+          pageCount: i.totalPages,
+          isLastPage: i.last
+        };
+      }
+    }).send();
+  }
+}
+const p = (s, t, e) => patientApi.metaStateRestful.postMetaState({
+  params: {
+    ownerId: s,
+    type: t
+  },
+  headers: {
+    "Content-Type": "application/octet-stream"
+  },
+  duplex: "half",
+  data: new Blob([e])
+}).send(), l = (s, t, e) => patientApi.metaStateRestful.putMetaState({
+  pathParams: {
+    id: s,
+    type: t
+  },
+  data: e
+}).send(), u = (s) => (patientApi.metaStateRestful.deleteMetaState({
+  pathParams: {
+    id: s
+  }
+}).send(), Promise.resolve()), c = (s) => patientApi.metaStateRestful.getMetaState({
+  pathParams: {
+    id: s
+  }
+}).send(), f = async (s) => patientApi.metaStateRestful.getMetaObject({
+  pathParams: {
+    id: s
+  },
+  priority: "low",
+  transform(t) {
+    return t.arrayBuffer();
+  }
+}).send(), v = (s, t) => {
+  const e = [], a = Date.now().toString();
+  return Object.entries(s).forEach(([o, h]) => {
+    e.push(
+      W.builder().key(o).annotations([H.builder().value(h).actor(t).timestamp(a).build()]).build()
+    );
+  }), e;
+};
+class X extends I {
+  async getObject() {
+    return this.base64Image ? Promise.resolve(this.base64Image) : this.deserialize(await f(this.id));
+  }
+  async get() {
+    return this.of(await c(this.id));
+  }
+  async put() {
+    return this.of(await l(this.id, this.type, this.state()));
+  }
+  async post() {
+    return this.of(await p(this.owner.id, this.type, this.serialize()));
+  }
+  async delete() {
+    return await u(this.id), this;
+  }
+  async analyze(t = !1) {
+    t && (this.tags = []);
+    const e = new FormData();
+    return e.append("files", new Blob([x(this.base64Image)])), this.tags.push(...v(await J(e).send(), "算法")), Promise.resolve(this);
+  }
+}
+class Y extends G {
+  async getObject() {
+    return this.base64Image ? Promise.resolve(this.base64Image) : this.deserialize(await f(this.id));
+  }
+  async post() {
+    return this.of(await p(this.owner.id, this.type, this.serialize()));
+  }
+  async get() {
+    return this.of(await c(this.id));
+  }
+  async put() {
+    return this.of(await l(this.id, this.type, this.state()));
+  }
+  async delete() {
+    return await u(this.id), this;
+  }
+  async analyze(t = !1) {
+    t && (this.tags = []);
+    const e = new FormData();
+    return e.append("files", new Blob([x(this.base64Image)])), this.tags.push(...v(await K(e).send(), "算法")), Promise.resolve(this);
+  }
+}
+class Z extends R {
+  async getObject() {
+    return this.base64Image ? Promise.resolve(this.base64Image) : this.deserialize(await f(this.id));
+  }
+  async post() {
+    return this.of(await p(this.owner.id, this.type, this.serialize()));
+  }
+  async get() {
+    return this.of(await c(this.id));
+  }
+  async put() {
+    return this.of(await l(this.id, this.type, this.state()));
+  }
+  async delete() {
+    return await u(this.id), this;
+  }
+  async analyze(t = !1) {
+    return t && (this.tags = []), Promise.resolve(this);
+  }
+}
+class _ extends q {
+  async getObject() {
+    return this.waves ? Promise.resolve(this.waves) : this.deserialize(await f(this.id));
+  }
+  async post() {
+    return this.of(await p(this.owner.id, this.type, this.serialize()));
+  }
+  async get() {
+    return this.of(await c(this.id));
+  }
+  async put() {
+    return this.of(await l(this.id, this.type, this.state()));
+  }
+  async delete() {
+    return await u(this.id), this;
+  }
+  async analyze(t = !1) {
+    t && (this.tags = []);
+    const e = {};
+    for (const a in this.waves?.origin)
+      e[a] = this.waves.origin[a].values;
+    return this.tags.push(...v(await Q(e).send(), "算法")), Promise.resolve(this);
+  }
+  preprocess(t) {
+    return U(t);
+  }
+}
+class $ extends B {
+  async getObject() {
+    return this.waves ? Promise.resolve(this.waves) : this.deserialize(await f(this.id));
+  }
+  async post() {
+    return this.of(await p(this.owner.id, this.type, this.serialize()));
+  }
+  async get() {
+    return this.of(await c(this.id));
+  }
+  async put() {
+    return this.of(await l(this.id, this.type, this.state()));
+  }
+  async delete() {
+    return await u(this.id), this;
+  }
+  async analyze(t = !1) {
+    t && (this.tags = []);
+    const e = {};
+    for (const a in this.waves?.origin)
+      e[a] = this.waves.origin[a].values;
+    return this.tags.push(...v(await z(e).send(), "算法")), Promise.resolve(this);
+  }
+  preprocess(t) {
+    return Promise.resolve(t);
+  }
+}
+class j extends k {
+  async getObject() {
+    return this.waves ? Promise.resolve(this.waves) : this.deserialize(await f(this.id));
+  }
+  async post() {
+    return this.of(await p(this.owner.id, this.type, this.serialize()));
+  }
+  async get() {
+    return this.of(await c(this.id));
+  }
+  async put() {
+    return this.of(await l(this.id, this.type, this.state()));
+  }
+  async delete() {
+    return await u(this.id), this;
+  }
+  async analyze(t = !1) {
+    t && (this.tags = []);
+    const e = {};
+    for (const a in this.waves?.origin)
+      e[a] = this.waves.origin[a].values;
+    return this.tags.push(...v(await z(e).send(), "算法")), Promise.resolve(this);
+  }
+  preprocess(t) {
+    return Promise.resolve(t);
+  }
+}
+class N extends D {
+  async getObject() {
+    return this.waves ? Promise.resolve(this.waves) : this.deserialize(await f(this.id));
+  }
+  async post() {
+    return this.of(await p(this.owner.id, this.type, this.serialize()));
+  }
+  async get() {
+    return this.of(await c(this.id));
+  }
+  async put() {
+    return this.of(await l(this.id, this.type, this.state()));
+  }
+  async delete() {
+    return await u(this.id), this;
+  }
+  async analyze(t = !1) {
+    t && (this.tags = []);
+    const e = {};
+    for (const a in this.waves?.origin)
+      e[a] = this.waves.origin[a].values;
+    return this.tags.push(...v(await z(e).send(), "算法")), Promise.resolve(this);
+  }
+  preprocess(t) {
+    return Promise.resolve(t);
+  }
+}
+class tt extends F {
+  async getObject() {
+    return this.base64Images.length ? Promise.resolve(this.base64Images) : this.deserialize(await f(this.id));
+  }
+  async post() {
+    return this.of(await p(this.owner.id, this.type, this.serialize()));
+  }
+  async get() {
+    return this.of(await c(this.id));
+  }
+  async put() {
+    return this.of(await l(this.id, this.type, this.state()));
+  }
+  async delete() {
+    return await u(this.id), this;
+  }
+  async analyze(t = !1) {
+    return t && (this.tags = []), Promise.resolve(this);
+  }
+}
+class et extends L {
+  async getObject() {
+    return this.text ? Promise.resolve(this.text) : this.deserialize(await f(this.id));
+  }
+  async post() {
+    return this.of(await p(this.owner.id, this.type, this.serialize()));
+  }
+  async get() {
+    return this.of(await c(this.id));
+  }
+  async put() {
+    return this.of(await l(this.id, this.type, this.state()));
+  }
+  async delete() {
+    return await u(this.id), this;
+  }
+  async analyze(t = !1) {
+    return t && (this.tags = []), Promise.resolve(this);
+  }
+}
+class M extends T {
+  static map(t) {
+    const e = n[t.type];
+    if (e == n.Pulsation) return new _().of(t);
+    if (e == n.Tongue) return new X().of(t);
+    if (e == n.Complaint) return new et().of(t);
+    if (e == n.Face) return new Y().of(t);
+    if (e == n.Appendix) return new tt().of(t);
+    if (e == n.ECG) return new N().of(t);
+    if (e == n.PCG) return new j().of(t);
+    if (e == n.Scene) return new Z().of(t);
+    if (e == n.PPG) return new $().of(t);
+    if (e == n.Meta) return new V().of(t);
+    throw new Error("未知的Meta类型");
+  }
+}
+export {
+  tt as AlovaAppendixMeta,
+  et as AlovaComplaintMeta,
+  N as AlovaECGMeta,
+  Y as AlovaFaceMeta,
+  V as AlovaMeta,
+  M as AlovaMetas,
+  j as AlovaPCGMeta,
+  $ as AlovaPPGMeta,
+  _ as AlovaPulsationMeta,
+  Z as AlovaSceneMeta,
+  X as AlovaTongueMeta
+};

package/dist/src/api/patient/alova/implement/patient.d.ts

@@ -0,0 +1,22 @@
+import { Patient } from '../../patient';
+import { Page } from '../../core';
+export declare class AlovaPatient extends Patient {
+    get(): Promise<this>;
+    put(): Promise<this>;
+    post(): Promise<this>;
+    delete(): Promise<Awaited<this>>;
+    putRemarks(): Promise<this>;
+    static query(params: {
+        id?: string;
+        doctorId?: string;
+        name?: string;
+        gender?: string;
+        identity?: string;
+        pageSize: number;
+        page: number;
+        phoneNumber?: string;
+        startTime?: string;
+        endTime?: string;
+        sort?: string;
+    }): Promise<Page<Patient>>;
+}

package/dist/src/api/patient/alova/implement/patient.js

@@ -0,0 +1,72 @@
+import { Patient as s } from "../../patient.js";
+class a extends s {
+  async get() {
+    return this.of(
+      await patientApi.patientStateRestful.getPatientState({
+        pathParams: {
+          id: this.id
+        },
+        priority: "high",
+        async transform(e) {
+          return new a().of(e);
+        }
+      }).send()
+    );
+  }
+  async put() {
+    return this.of(
+      await patientApi.patientStateRestful.putPatientState({
+        pathParams: {
+          id: this.id
+        },
+        data: this.state()
+      }).send(!0)
+    );
+  }
+  async post() {
+    return this.of(
+      await patientApi.patientStateRestful.postPatientState({
+        data: this.state()
+      }).send(!0)
+    );
+  }
+  delete() {
+    return patientApi.patientStateRestful.deletePatientState({
+      pathParams: {
+        id: this.id
+      }
+    }).send(), Promise.resolve(this);
+  }
+  async putRemarks() {
+    return this.of(
+      await patientApi.patientStateRestful.putPatientState({
+        pathParams: {
+          id: this.id
+        },
+        data: {
+          remarks: this.remarks
+        }
+      }).send(!0)
+    );
+  }
+  static query(e) {
+    return patientApi.patientStateRestful.queryPatientState({
+      params: e,
+      async transform(t) {
+        return {
+          data: await Promise.all(
+            t.content.map((i) => new a().of(i))
+          ),
+          total: t.totalElements,
+          page: t.number,
+          pageCount: t.totalPages,
+          pageSize: t.size,
+          isLastPage: t.last
+        };
+      }
+    }).send();
+  }
+}
+export {
+  a as AlovaPatient
+};

package/dist/src/api/patient/alova/index.d.ts

@@ -0,0 +1,5 @@
+export declare const alovaInstance: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, any, any, any>>;
+export declare const $$userConfigMap: {};
+declare const Apis: patientApi;
+export * from './implement';
+export default Apis;

package/dist/src/api/patient/alova/index.js

@@ -0,0 +1,22 @@
+import { createAlova as e } from "../../../../node_modules/alova/dist/alova.esm.js";
+import t from "../../../../node_modules/alova/dist/adapter/fetch.esm.js";
+import { createApis as o, mountApis as r, withConfigType as i } from "./createApis.js";
+import { responded as p, onAuthRequired as a } from "../../config/alova/index.js";
+import { getServiceEndpoint as m, ServiceType as n } from "../../config/index.js";
+import "../core.js";
+import "../../../../node_modules/pinyin/lib/esm/pinyin.js";
+import "../../algorithm/index.js";
+const s = e({
+  baseURL: m(n.Patient),
+  requestAdapter: t(),
+  beforeRequest: a(() => {
+  }),
+  cacheFor: null,
+  responded: p
+}), c = i({}), f = o(s, c);
+r(f);
+export {
+  c as $$userConfigMap,
+  s as alovaInstance,
+  f as default
+};

package/dist/src/api/patient/core.d.ts

@@ -0,0 +1,50 @@
+import { AnnotationState, TagState } from './alova/globals';
+import { IBuilder } from 'builder-pattern';
+export declare class Page<T> {
+    data: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    isLastPage: boolean;
+}
+declare abstract class NetworkObject {
+    static _default: typeof NetworkObject;
+    static builder(): IBuilder<unknown>;
+    static default(): typeof NetworkObject;
+    abstract of(json: unknown): Promise<this>;
+    abstract state(): unknown;
+}
+declare class Annotation extends NetworkObject {
+    value: string;
+    actor: string;
+    timestamp: string;
+    static builder(): IBuilder<Annotation>;
+    constructor(value?: string, actor?: string, timestamp?: string);
+    of(json: AnnotationState): Promise<Awaited<this>>;
+    state(): AnnotationState;
+}
+declare class Tag extends NetworkObject {
+    static builder(): IBuilder<Tag>;
+    static default(): typeof Tag;
+    key: string;
+    annotations: Annotation[];
+    constructor(key?: string, annotations?: Annotation[]);
+    of(json: TagState): Promise<this>;
+    state(): TagState;
+    getLastValue(): string;
+    getLastAnnotation(): Annotation;
+    static getValueTagSet(tags: Tag[]): Tag[];
+    assign(tag: Tag): this;
+}
+declare class Sequence<T> {
+    data: T[];
+    current: T;
+    showed: boolean;
+    constructor(data?: T[], current?: T);
+    delete(item: T): T;
+    choose(item: T): T;
+    clear(): this;
+    show(): Sequence<T>;
+}
+export { NetworkObject, Tag, Sequence, Annotation };

package/dist/src/api/patient/core.js

@@ -0,0 +1,109 @@
+import { Builder as i } from "../../../node_modules/builder-pattern/dist/index.js";
+class d {
+  data = [];
+  total = 0;
+  page = 0;
+  pageSize = 0;
+  pageCount = 0;
+  isLastPage = !1;
+}
+class a {
+  static _default = a;
+  static builder() {
+    return i(this._default);
+  }
+  static default() {
+    return a;
+  }
+}
+class r extends a {
+  value = "";
+  actor = "";
+  timestamp = "";
+  static builder() {
+    return i(r);
+  }
+  constructor(t = "", e = "", s = "") {
+    super(), this.value = t, this.actor = e, this.timestamp = s;
+  }
+  of(t) {
+    return this.value = t.value, this.actor = t.actor, this.timestamp = t.timestamp, Promise.resolve(this);
+  }
+  state() {
+    return {
+      value: this.value,
+      actor: this.actor,
+      timestamp: this.timestamp
+    };
+  }
+}
+class n extends a {
+  static builder() {
+    return i(n);
+  }
+  static default() {
+    return n;
+  }
+  key = "";
+  annotations = [];
+  constructor(t = "", e = []) {
+    super(), this.key = t, this.annotations = e;
+  }
+  async of(t) {
+    this.key = t.key;
+    for (const e of t.annotationsState)
+      this.annotations.push(await new r().of(e));
+    return this;
+  }
+  state() {
+    return {
+      key: this.key,
+      annotationsState: this.annotations.map((t) => t.state())
+    };
+  }
+  getLastValue() {
+    return this.getLastAnnotation().value;
+  }
+  getLastAnnotation() {
+    return this.annotations[this.annotations.length - 1];
+  }
+  static getValueTagSet(t) {
+    const e = [];
+    return t.forEach((s) => {
+      const h = s.key, c = s.getLastAnnotation().value.slice(0, 10);
+      e.find(
+        (o) => o.key == h && o.getLastAnnotation().value.slice(0, 10) == c
+      ) || e.push(s);
+    }), e;
+  }
+  assign(t) {
+    return this.key = t.key, this.annotations = t.annotations, this;
+  }
+}
+class f {
+  data = [];
+  current = {};
+  showed = !1;
+  constructor(t = [], e = {}) {
+    this.data = t, this.current = e;
+  }
+  delete(t) {
+    return this.data.splice(this.data.indexOf(t), 1), t;
+  }
+  choose(t) {
+    return this.current = t, t;
+  }
+  clear() {
+    return this.data.length = 0, this.current = {}, this;
+  }
+  show() {
+    return this.showed = !0, this;
+  }
+}
+export {
+  r as Annotation,
+  a as NetworkObject,
+  d as Page,
+  f as Sequence,
+  n as Tag
+};