web-core-tcm 0.0.25 → 0.0.27

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

@@ -0,0 +1,454 @@
+import { NetworkObject as B, Tag as E, Sequence as C } from "./core.js";
+import { arrayBufferToImageBase64 as w } from "../../util/image.js";
+import { WaveMapSchema as h, WaveSchema as q } from "../../proto/types/WaveMap_pb.js";
+import { ImageSchema as g, ImagesSchema as P } from "../../proto/types/Images_pb.js";
+import { Patient as S } from "./patient.js";
+import { Builder as c } from "../../../node_modules/builder-pattern/dist/index.js";
+import { toBinary as m } from "../../../node_modules/@bufbuild/protobuf/dist/esm/to-binary.js";
+import { fromBinary as T } from "../../../node_modules/@bufbuild/protobuf/dist/esm/from-binary.js";
+import { create as l } from "../../../node_modules/@bufbuild/protobuf/dist/esm/create.js";
+var y = /* @__PURE__ */ ((a) => (a.Pulsation = "pulsation", a.Tongue = "tongue", a.Appendix = "appendix", a.PPG = "ppg", a.PCG = "pcg", a.ECG = "ecg", a.Scene = "scene", a.Face = "face", a.Complaint = "complaint", a.Meta = "meta", a))(y || {});
+class p extends B {
+  static builder() {
+    return c(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  id = "";
+  owner = S.builder().build();
+  type = "face";
+  tags = [];
+  createdTimestamp = "0";
+  updatedTimestamp = "0";
+  isSelected = !1;
+  async of(t) {
+    return t.id != null && (this.id = t.id), t.ownerState != null && (this.owner = await S.builder().build().of(t.ownerState)), t.tagsState != null && (this.tags = await Promise.all(t.tagsState.map((e) => E.builder().build().of(e)))), t.createdTimestamp != null && (this.createdTimestamp = t.createdTimestamp), t.updatedTimestamp != null && (this.updatedTimestamp = t.updatedTimestamp), t.type != null && (this.type = t.type), Promise.resolve(this);
+  }
+  state() {
+    return {
+      id: this.id,
+      ownerState: this.owner.state(),
+      type: this.type,
+      tagsState: this.tags.map((t) => t.state()),
+      createdTimestamp: this.createdTimestamp,
+      updatedTimestamp: this.updatedTimestamp
+    };
+  }
+  getTagValue(t) {
+    const e = this.tags.find((s) => s.key == t)?.getLastAnnotation();
+    return e ? e.value : "";
+  }
+  putTags() {
+    return patientApi.metaStateRestful.putMetaState({
+      pathParams: {
+        id: this.id
+      },
+      data: {
+        id: this.id,
+        tagsState: this.tags.map((t) => t.state())
+      }
+    });
+  }
+  addTag(t) {
+    return this.tags.push(t), this.putTags();
+  }
+  removeTag(t) {
+    return this.tags.splice(this.tags.indexOf(t), 1), this.putTags();
+  }
+  static queryMetaWithPatient(t, e, s, i, r, n, o, d, x, v, _, M, f) {
+    return this.default().queryMetaWithPatient(
+      t,
+      e,
+      s,
+      i,
+      r,
+      n,
+      o,
+      d,
+      x,
+      v,
+      _,
+      M,
+      f
+    );
+  }
+  static query(t, e, s, i, r, n, o = "createdTimestamp:asc") {
+    return this.default().query(t, e, s, i, r, n, o);
+  }
+  static queryMetaStateByExactMatch(t, e, s, i, r, n, o, d) {
+    return this.default().queryMetaStateByExactMatch(
+      t,
+      e,
+      s,
+      i,
+      r,
+      n,
+      o,
+      d
+    );
+  }
+}
+class A extends p {
+  image;
+  base64Image = "";
+  // 测试序列化往返
+  serialize() {
+    if (!this.image) throw new Error("not found");
+    return m(g, this.image).buffer;
+  }
+  deserialize(t) {
+    return this.image = T(g, new Uint8Array(t)), this.base64Image = w(this.image.bytes), this.base64Image;
+  }
+  inject(t) {
+    return t && (this.image = l(g, {
+      bytes: new Uint8Array(t)
+    }), this.base64Image = w(new Uint8Array(t))), Promise.resolve(this);
+  }
+}
+class z extends p {
+  images;
+  base64Images = [];
+  serialize() {
+    if (!this.images) throw new Error("not found");
+    return m(P, this.images).buffer;
+  }
+  deserialize(t) {
+    return this.images = T(P, new Uint8Array(t)), this.base64Images = this.images.images.map((e) => w(e.bytes)), this.base64Images;
+  }
+  inject(t) {
+    return t && (this.images = l(P, {
+      images: t.map((e) => l(g, {
+        bytes: new Uint8Array(e)
+      }))
+    }), this.base64Images = t.map((e) => w(new Uint8Array(e)))), Promise.resolve(this);
+  }
+}
+class F extends p {
+  text = "";
+  constructor() {
+    super();
+  }
+  serialize() {
+    return new TextEncoder().encode(this.text).buffer;
+  }
+  deserialize(t) {
+    return this.text = new TextDecoder().decode(t), this.text;
+  }
+  inject(t) {
+    return t && (this.text = t), Promise.resolve(this);
+  }
+}
+class b extends p {
+  waves;
+  serialize() {
+    if (console.log("serialize", this.waves), this.waves && (console.log("seruia"), console.log(m(h, this.waves), m(h, this.waves).buffer), console.log("sss")), !this.waves) throw new Error("not found");
+    return m(h, this.waves).buffer;
+  }
+  deserialize(t) {
+    return this.waves = T(h, new Uint8Array(t)), this.waves;
+  }
+  async inject(t, e) {
+    return !e && t && (e = await this.preprocess(t)), console.log(t, e), t && e && (console.log(this.waves), this.waves = l(h, {
+      origin: Object.fromEntries(
+        Object.entries(t).map(([s, i]) => [
+          s,
+          l(q, {
+            values: i
+          })
+        ])
+      ),
+      smooth: Object.fromEntries(
+        Object.entries(e).map(([s, i]) => [
+          s,
+          l(q, {
+            values: i
+          })
+        ])
+      )
+    }), console.log(this.waves)), Promise.resolve(this);
+  }
+}
+class O extends A {
+  static builder() {
+    return c(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  constructor() {
+    super(), this.type = "tongue";
+  }
+}
+class U extends A {
+  static builder() {
+    return c(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  constructor() {
+    super(), this.type = "face";
+  }
+}
+class W extends A {
+  static builder() {
+    return c(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  constructor() {
+    super(), this.type = "scene";
+  }
+}
+class G extends b {
+  static builder() {
+    return c(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  constructor() {
+    super(), this.type = "pulsation";
+  }
+}
+class D extends b {
+  static builder() {
+    return c(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  constructor() {
+    super(), this.type = "ppg";
+  }
+}
+class k extends b {
+  static builder() {
+    return c(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  constructor() {
+    super(), this.type = "pcg";
+  }
+}
+class j extends b {
+  static builder() {
+    return c(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  constructor() {
+    super(), this.type = "ecg";
+  }
+}
+class L extends z {
+  static builder() {
+    return c(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  constructor() {
+    super(), this.type = "appendix";
+  }
+}
+class N extends F {
+  static builder() {
+    return c(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  constructor() {
+    super(), this.type = "complaint";
+  }
+}
+class u extends C {
+  type;
+  owner;
+  expand = !1;
+  constructor(t, e) {
+    super(), this.type = t, e && (this.owner = e);
+  }
+  init(t) {
+    this.clear(), this.owner = S.builder().id(t.id).build();
+  }
+  async query(t, e, s, i, r) {
+    return this.clear(), this.append(t, e, s, i, r);
+  }
+  async append(t, e, s, i, r) {
+    const n = await p.query(
+      t,
+      e,
+      this.owner,
+      this.type,
+      s,
+      i,
+      r
+    );
+    return this.data.unshift(...n.data.reverse()), n;
+  }
+  async appendMetaWithPatient(t, e, s, i, r, n, o, d, x, v, _, M) {
+    const f = await p.queryMetaWithPatient(
+      t,
+      e,
+      this.owner,
+      s,
+      i,
+      r,
+      n,
+      o,
+      d,
+      x,
+      v,
+      _,
+      M
+    );
+    return this.data.unshift(...f.data.reverse()), f;
+  }
+}
+const R = {
+  face: { type: U, name: "面象", icon: "face", color: "#FF6B6B" },
+  tongue: { type: O, name: "舌象", icon: "face", color: "#4ECDC4" },
+  complaint: { type: N, name: "主诉", icon: "message", color: "#FFD166" },
+  pulsation: { type: G, name: "脉象", icon: "ssid_chart", color: "#06D6A0" },
+  ecg: { type: j, name: "心电", icon: "ssid_chart", color: "#118AB2" },
+  pcg: { type: k, name: "心音", icon: "ssid_chart", color: "#073B4C" },
+  ppg: { type: D, name: "心光", icon: "ssid_chart", color: "#7209B7" },
+  scene: { type: W, name: "场景", icon: "house", color: "#F72585" },
+  appendix: { type: L, name: "附件", icon: "folder_open", color: "#3A86FF" },
+  meta: { type: p, name: "元", icon: "tag", color: "#8338EC" }
+};
+class I {
+  static _default;
+  static builder() {
+    return c(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  face = new u(
+    "face"
+    /* Face */
+  );
+  tongue = new u(
+    "tongue"
+    /* Tongue */
+  );
+  complaint = new u(
+    "complaint"
+    /* Complaint */
+  );
+  pulsation = new u(
+    "pulsation"
+    /* Pulsation */
+  );
+  ecg = new u(
+    "ecg"
+    /* ECG */
+  );
+  pcg = new u(
+    "pcg"
+    /* PCG */
+  );
+  ppg = new u(
+    "ppg"
+    /* PPG */
+  );
+  scene = new u(
+    "scene"
+    /* Scene */
+  );
+  appendix = new u(
+    "appendix"
+    /* Appendix */
+  );
+  meta = new u(
+    "meta"
+    /* Meta */
+  );
+  faces = this.face;
+  tongues = this.tongue;
+  complaints = this.complaint;
+  pulsations = this.pulsation;
+  ecgs = this.ecg;
+  pcgs = this.pcg;
+  ppgs = this.ppg;
+  scenes = this.scene;
+  appendixes = this.appendix;
+  metas = this.meta;
+  constructor(t) {
+    t && this.addMetas(t);
+  }
+  init(t) {
+    for (const e of Object.values(y))
+      this[e].init(t);
+    return this;
+  }
+  async query(t, e, s, i, r) {
+    for (const n of Object.values(y)) {
+      const o = await this[n].query(t, e, s, i, r);
+      for (const d of o.data)
+        this[n].data.push(d);
+    }
+    return this;
+  }
+  addMetas(t) {
+    for (const e of t)
+      this.addMeta(e);
+    return this;
+  }
+  addMeta(t) {
+    const e = this[t.type].data.find((s) => s.id == t.id);
+    return e ? e.of(t) : this[t.type].data.unshift(t), this;
+  }
+  clear() {
+    for (const t of Object.values(y))
+      this[t].clear();
+  }
+  static map(t) {
+    return I.default().map(t);
+  }
+  static mapText(t) {
+    return R[t].name;
+  }
+  static standards() {
+    return [
+      "face",
+      "tongue",
+      "complaint",
+      "pulsation",
+      "ecg",
+      "pcg",
+      "ppg",
+      "scene",
+      "appendix"
+      /* Appendix */
+    ];
+  }
+}
+export {
+  L as AppendixMeta,
+  N as ComplaintMeta,
+  j as ECGMeta,
+  U as FaceMeta,
+  A as ImageMeta,
+  z as ImagesMeta,
+  p as Meta,
+  u as MetaSequence,
+  y as MetaType,
+  R as MetaTypeConfig,
+  I as Metas,
+  k as PCGMeta,
+  D as PPGMeta,
+  G as PulsationMeta,
+  W as SceneMeta,
+  F as TextMeta,
+  O as TongueMeta,
+  b as WavesMeta
+};

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

@@ -0,0 +1,43 @@
+import { Page, Tag, NetworkObject } from './core';
+import { PatientState } from './alova/globals';
+import { Metas } from './meta';
+import { IBuilder } from 'builder-pattern';
+export declare abstract class Patient extends NetworkObject {
+    static builder(): IBuilder<Patient>;
+    static default(): typeof Patient;
+    id: string;
+    name: string;
+    gender: string;
+    phoneNumber: string;
+    birthdate: string;
+    identity: string;
+    age: number;
+    tags: Tag[];
+    remarks: string[];
+    doctorId: string;
+    createdTimestamp: string;
+    updatedTimestamp: string;
+    mainSymptom: string;
+    metas: Metas;
+    init(id?: string, metas?: Metas): void;
+    of(json: PatientState): Promise<this>;
+    state(): PatientState;
+    abstract get(): Promise<this>;
+    abstract put(): Promise<this>;
+    abstract post(): Promise<this>;
+    abstract delete(): Promise<this>;
+    abstract 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/patient.js

@@ -0,0 +1,42 @@
+import { NetworkObject as e, Tag as a } from "./core.js";
+import { Metas as d } from "./meta.js";
+import { Builder as m } from "../../../node_modules/builder-pattern/dist/index.js";
+import { getName as r } from "../../util/string.js";
+class o extends e {
+  static builder() {
+    return m(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  id = "";
+  name = "";
+  gender = "";
+  phoneNumber = "";
+  birthdate = "";
+  identity = "";
+  age = 0;
+  tags = [];
+  remarks = [];
+  doctorId = "";
+  createdTimestamp = "";
+  updatedTimestamp = "";
+  mainSymptom = "";
+  metas = d.builder().build();
+  init(t, i) {
+    t && (this.id = t), i && (this.metas = i), this.metas.init(this);
+  }
+  async of(t) {
+    return t.id != null && (this.id = t.id), t.name != null && (this.name = r(t.name)), t.gender != null && (this.gender = t.gender), t.phoneNumber != null && (this.phoneNumber = t.phoneNumber), t.birthdate != null && (this.birthdate = t.birthdate, this.age = (/* @__PURE__ */ new Date()).getFullYear() - new Date(t.birthdate).getFullYear()), t.identity != null && (this.identity = t.identity), t.tagsState != null && (this.tags = await Promise.all(t.tagsState.map((i) => a.builder().build().of(i)))), t.remarks != null && (this.remarks = t.remarks), t.doctorId != null && (this.doctorId = t.doctorId), t.createdTimestamp != null && (this.createdTimestamp = t.createdTimestamp), t.updatedTimestamp != null && (this.updatedTimestamp = t.updatedTimestamp), t.mainSymptom != null && (this.mainSymptom = t.mainSymptom), this.metas = this.metas.init(this), this;
+  }
+  state() {
+    const t = {};
+    return this.id && (t.id = this.id), this.name && (t.name = this.name), this.gender && (t.gender = this.gender), this.phoneNumber && (t.phoneNumber = this.phoneNumber), this.birthdate && (t.birthdate = this.birthdate), this.identity && (t.identity = this.identity), this.tags.length > 0 && (t.tagsState = this.tags.map((i) => i.state())), this.doctorId && (t.doctorId = this.doctorId), this.createdTimestamp && (t.createdTimestamp = this.createdTimestamp), this.updatedTimestamp && (t.updatedTimestamp = this.updatedTimestamp), this.mainSymptom && (t.mainSymptom = this.mainSymptom), this.remarks.length > 0 && (t.remarks = this.remarks), t;
+  }
+  static query(t) {
+    return this.default().query(t);
+  }
+}
+export {
+  o as Patient
+};

package/dist/src/api/prescription/alova/apiDefinitions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * OpenAPI definition - version v0
+ *
+ *
+ *
+ * OpenAPI version: 3.1.0
+ *
+ *
+ * NOTE: This file is auto generated by the alova's vscode plugin.
+ *
+ * https://alova.js.org/devtools/vscode
+ *
+ * **Do not edit the file manually.**
+ */
+declare const _default: {
+    'prescriptionRestful.getPrescriptionState': string[];
+    'prescriptionRestful.putPrescriptionState': string[];
+    'prescriptionRestful.deletePrescriptionState': string[];
+    'herbalRestful.getHerbalState': string[];
+    'herbalRestful.putHerbalState': string[];
+    'herbalRestful.deleteHerbalState': string[];
+    'herbalRestful.postHerbalState': string[];
+    'prescriptionRestful.postPrescriptionState': string[];
+    'prescriptionRestful.queryPrescriptionState': string[];
+    'herbalRestful.queryHerbalState': string[];
+};
+export default _default;

package/dist/src/api/prescription/alova/apiDefinitions.js

@@ -0,0 +1,15 @@
+const e = {
+  "prescriptionRestful.getPrescriptionState": ["GET", "/药材/服务/药方/{id}"],
+  "prescriptionRestful.putPrescriptionState": ["PUT", "/药材/服务/药方/{id}"],
+  "prescriptionRestful.deletePrescriptionState": ["DELETE", "/药材/服务/药方/{id}"],
+  "herbalRestful.getHerbalState": ["GET", "/药材/服务/{id}"],
+  "herbalRestful.putHerbalState": ["PUT", "/药材/服务/{id}"],
+  "herbalRestful.deleteHerbalState": ["DELETE", "/药材/服务/{id}"],
+  "herbalRestful.postHerbalState": ["POST", "/药材/服务"],
+  "prescriptionRestful.postPrescriptionState": ["POST", "/药材/服务/药方"],
+  "prescriptionRestful.queryPrescriptionState": ["POST", "/药材/服务/药方/条件查询"],
+  "herbalRestful.queryHerbalState": ["POST", "/药材/服务/条件查询"]
+};
+export {
+  e as default
+};

package/dist/src/api/prescription/alova/createApis.d.ts

@@ -0,0 +1,10 @@
+import { Alova, AlovaGenerics, AlovaMethodCreateConfig } from 'alova';
+export declare const createApis: (alovaInstance: Alova<AlovaGenerics>, configMap: any) => prescriptionApi;
+export declare const mountApis: (Apis: prescriptionApi) => void;
+type MethodConfig<T> = AlovaMethodCreateConfig<(typeof import('./index'))['alovaInstance'] extends Alova<infer AG> ? AG : any, any, T>;
+type APISofParameters<Tag extends string, Url extends string> = Tag extends keyof prescriptionApi ? Url extends keyof prescriptionApi[Tag] ? prescriptionApi[Tag][Url] extends (...args: any) => any ? Parameters<prescriptionApi[Tag][Url]> : any : any : any;
+type MethodsConfigMap = {
+    [P in keyof typeof import('./apiDefinitions').default]?: MethodConfig<P extends `${infer Tag}.${infer Url}` ? Parameters<NonNullable<APISofParameters<Tag, Url>[0]>['transform']>[0] : any>;
+};
+export declare const withConfigType: <Config extends MethodsConfigMap>(config: Config) => Config;
+export {};

package/dist/src/api/prescription/alova/createApis.js

@@ -0,0 +1,51 @@
+import { Method as g } from "../../../../node_modules/alova/dist/alova.esm.js";
+import A from "./apiDefinitions.js";
+const l = /* @__PURE__ */ Object.create(null), h = (t, r, i) => {
+  const e = t.join(".");
+  if (l[e])
+    return l[e];
+  const n = new Proxy(function() {
+  }, {
+    get(d, m) {
+      const s = [...t, m];
+      return h(s, r, i);
+    },
+    apply(d, m, [s]) {
+      const u = A[e];
+      if (!u)
+        throw new Error(`the api path of \`${e}\` is not found`);
+      const a = {
+        ...i[e],
+        ...s
+      }, [y, P] = u, w = a.pathParams, b = P.replace(/\{([^}]+)\}/g, (f, p) => w[p]);
+      delete a.pathParams;
+      let o = a.data;
+      if (Object.prototype.toString.call(o) === "[object Object]" && typeof FormData < "u") {
+        let f = !1;
+        const p = new FormData();
+        for (const c in o)
+          p.append(c, o[c]), o[c] instanceof Blob && (f = !0);
+        o = f ? p : o;
+      }
+      return new g(
+        y.toUpperCase(),
+        r,
+        b,
+        a,
+        o
+      );
+    }
+  });
+  return l[e] = n, n;
+}, x = (t, r) => new Proxy({}, {
+  get(e, n) {
+    return h([n], t, r);
+  }
+}), D = (t) => {
+  globalThis.prescriptionApi = t;
+}, C = (t) => t;
+export {
+  x as createApis,
+  D as mountApis,
+  C as withConfigType
+};

package/dist/src/api/prescription/alova/implement/herbal.d.ts

@@ -0,0 +1,15 @@
+import { Herbal } from '../../herbal';
+import { Doctor } from '../../../doctor/doctor';
+export declare class AlovaHerbal extends Herbal {
+    static query(page?: number, pageSize?: number, owner?: Doctor, name?: string, price?: number): Promise<{
+        data: Herbal[];
+        total: number;
+        page: number;
+        pageSize: number;
+        pageCount: number;
+        isLastPage: boolean;
+    }>;
+    put(): Promise<this>;
+    post(): Promise<this>;
+    delete(): Promise<void>;
+}