web-core-tcm 0.0.25 → 0.0.27

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

@@ -0,0 +1,10 @@
+import { Alova, AlovaGenerics, AlovaMethodCreateConfig } from 'alova';
+export declare const createApis: (alovaInstance: Alova<AlovaGenerics>, configMap: any) => outpatientApi;
+export declare const mountApis: (Apis: outpatientApi) => 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 outpatientApi ? Url extends keyof outpatientApi[Tag] ? outpatientApi[Tag][Url] extends (...args: any) => any ? Parameters<outpatientApi[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/outpatient/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, n, i) => {
+  const e = t.join(".");
+  if (l[e])
+    return l[e];
+  const r = new Proxy(function() {
+  }, {
+    get(d, u) {
+      const s = [...t, u];
+      return h(s, n, i);
+    },
+    apply(d, u, [s]) {
+      const m = A[e];
+      if (!m)
+        throw new Error(`the api path of \`${e}\` is not found`);
+      const a = {
+        ...i[e],
+        ...s
+      }, [y, P] = m, 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(),
+        n,
+        b,
+        a,
+        o
+      );
+    }
+  });
+  return l[e] = r, r;
+}, x = (t, n) => new Proxy({}, {
+  get(e, r) {
+    return h([r], t, n);
+  }
+}), D = (t) => {
+  globalThis.outpatientApi = t;
+}, C = (t) => t;
+export {
+  x as createApis,
+  D as mountApis,
+  C as withConfigType
+};

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

@@ -0,0 +1,10 @@
+import { Queuer } from '../../outpatient';
+import { Page } from '../../../patient/core';
+export declare class AlovaQueuer extends Queuer {
+    get(): Promise<this>;
+    put(): Promise<this>;
+    delete(): Promise<this>;
+    post(): Promise<this>;
+    putStatus(status?: number): Promise<this>;
+    static query(page: number, pageSize: number, doctorId?: string, patientId?: string): Promise<Page<Queuer>>;
+}

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

@@ -0,0 +1,71 @@
+import { Queuer as p } from "../../outpatient.js";
+class s extends p {
+  async get() {
+    return this.of(
+      await outpatientApi.queuerRestful.getQueuerState({
+        pathParams: {
+          id: this.id
+        }
+      }).send()
+    );
+  }
+  async put() {
+    return this.of(
+      await outpatientApi.queuerRestful.putQueuerState({
+        pathParams: {
+          id: this.id
+        },
+        data: this.state()
+      }).send(!0)
+    );
+  }
+  async delete() {
+    return await outpatientApi.queuerRestful.deleteQueuerState({
+      pathParams: {
+        id: this.id
+      }
+    }).send(), Promise.resolve(this);
+  }
+  async post() {
+    return this.of(
+      await outpatientApi.queuerRestful.postQueuerState({
+        data: this.state()
+      }).send(!0)
+    );
+  }
+  async putStatus(e) {
+    return e && (this.status = e), this.of(
+      await outpatientApi.queuerRestful.putQueuerState({
+        pathParams: {
+          id: this.id
+        },
+        data: {
+          status: this.status
+        }
+      }).send(!0)
+    );
+  }
+  static query(e, i, a, u) {
+    return outpatientApi.queuerRestful.queryQueuerState({
+      params: {
+        ...a && { doctorId: a },
+        ...u && { patientId: u },
+        page: e,
+        pageSize: i
+      },
+      async transform(t) {
+        return {
+          data: await Promise.all(t.content.map((r) => new s().of(r))),
+          total: t.totalElements,
+          page: t.number,
+          pageSize: t.size,
+          pageCount: t.totalPages,
+          isLastPage: t.last
+        };
+      }
+    }).send();
+  }
+}
+export {
+  s as AlovaQueuer
+};

package/dist/src/api/outpatient/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: outpatientApi;
+export default Apis;
+export * from './implement';

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

@@ -0,0 +1,21 @@
+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 p } from "./createApis.js";
+import { responded as i, onAuthRequired as a } from "../../config/alova/index.js";
+import { getServiceEndpoint as n, ServiceType as m } from "../../config/index.js";
+import "../../patient/core.js";
+import "../../../../node_modules/pinyin/lib/esm/pinyin.js";
+const s = e({
+  baseURL: n(m.Outpatient),
+  requestAdapter: t(),
+  beforeRequest: a(() => {
+  }),
+  cacheFor: null,
+  responded: i
+}), c = p({}), f = o(s, c);
+r(f);
+export {
+  c as $$userConfigMap,
+  s as alovaInstance,
+  f as default
+};

package/dist/src/api/outpatient/index.js

@@ -0,0 +1,11 @@
+import { Queuer as u, QueuerStatus as o, QueuerStatusConfig as t } from "./outpatient.js";
+import { $$userConfigMap as f, alovaInstance as n } from "./alova/index.js";
+import { AlovaQueuer as s } from "./alova/implement/outpatient.js";
+export {
+  f as $$userConfigMap,
+  s as AlovaQueuer,
+  u as Queuer,
+  o as QueuerStatus,
+  t as QueuerStatusConfig,
+  n as alovaInstance
+};

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

@@ -0,0 +1,39 @@
+import { Page, NetworkObject } from '../patient/core';
+import { QueuerState } from './alova/globals';
+import { IBuilder } from 'builder-pattern';
+import { Patient } from '../patient/patient';
+import { Doctor } from '../doctor/doctor';
+export declare enum QueuerStatus {
+    Waiting = 0,
+    InTreatment = 1,
+    Finished = 2
+}
+export declare const QueuerStatusConfig: {
+    2: {
+        name: string;
+    };
+    1: {
+        name: string;
+    };
+    0: {
+        name: string;
+    };
+};
+export declare abstract class Queuer extends NetworkObject {
+    static builder(): IBuilder<Queuer>;
+    static default(): typeof Queuer;
+    id: string;
+    patient: Patient;
+    doctor: Doctor;
+    createdTimestamp: string;
+    updatedTimestamp: string;
+    status: QueuerStatus;
+    of(json: QueuerState): Promise<this>;
+    state(): QueuerState;
+    static query(page: number, pageSize: number, doctorId?: string, patientId?: string): Promise<Page<Queuer>>;
+    abstract get(): Promise<this>;
+    abstract put(): Promise<this>;
+    abstract putStatus(status?: number): Promise<this>;
+    abstract delete(): Promise<this>;
+    abstract post(): Promise<this>;
+}

package/dist/src/api/outpatient/outpatient.js

@@ -0,0 +1,45 @@
+import { NetworkObject as s } from "../patient/core.js";
+import { Builder as m } from "../../../node_modules/builder-pattern/dist/index.js";
+import { Patient as p } from "../patient/patient.js";
+import { Doctor as o } from "../doctor/doctor.js";
+var c = /* @__PURE__ */ ((i) => (i[i.Waiting = 0] = "Waiting", i[i.InTreatment = 1] = "InTreatment", i[i.Finished = 2] = "Finished", i))(c || {});
+const T = {
+  2: { name: "完成" },
+  1: { name: "就诊" },
+  0: { name: "等待" }
+};
+class e extends s {
+  static builder() {
+    return m(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  id = "";
+  patient = p.builder().build();
+  doctor = o.builder().build();
+  createdTimestamp = "";
+  updatedTimestamp = "";
+  status = 0;
+  async of(t) {
+    return t.id != null && (this.id = t.id), t.patientState != null && await this.patient.of(t.patientState), t.doctorState != null && await this.doctor.of(t.doctorState), t.createdTimestamp != null && (this.createdTimestamp = t.createdTimestamp), t.updatedTimestamp != null && (this.updatedTimestamp = t.updatedTimestamp), t.status != null && (this.status = t.status), Promise.resolve(this);
+  }
+  state() {
+    return {
+      id: this.id,
+      patientState: this.patient.state(),
+      doctorState: this.doctor.state(),
+      createdTimestamp: this.createdTimestamp,
+      updatedTimestamp: this.updatedTimestamp,
+      status: this.status
+    };
+  }
+  static query(t, a, d, r) {
+    return e.default().query(t, a, d, r);
+  }
+}
+export {
+  e as Queuer,
+  c as QueuerStatus,
+  T as QueuerStatusConfig
+};

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

@@ -0,0 +1,39 @@
+/**
+ * 患者服务 - version v1.0
+ *
+ * 支持Restful风格的患者服务
+ *
+ * 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: {
+    'metaStateRestful.getMetaState': string[];
+    'metaStateRestful.putMetaState': string[];
+    'metaStateRestful.deleteMetaState': string[];
+    'patientStateRestful.getPatientState': string[];
+    'patientStateRestful.putPatientState': string[];
+    'patientStateRestful.deletePatientState': string[];
+    'patientStateRestful.queryPatientState': string[];
+    'patientStateRestful.postPatientState': string[];
+    'patientStateRestful.queryPatientStateByExactMatch': string[];
+    'metaStateRestful.postMetaState': string[];
+    'metaStateRestful.queryMetaAndPatientState': string[];
+    'metaStateRestful.queryMetaStateByExactMatch': string[];
+    'metaStateRestful.queryMetaState': string[];
+    'metricRestful.totalOfPatient': string[];
+    'metricRestful.ageDistributeOfPatient': string[];
+    'metricRestful.genderDistributeOfPatient': string[];
+    'metricRestful.dateDistributeOfPatient': string[];
+    'metricRestful.totalOfPatientByToday': string[];
+    'metricRestful.datesOfMeta': string[];
+    'metricRestful.totalOfMeta': string[];
+    'metricRestful.totalOfMetaByToday': string[];
+    'metaStateRestful.getMetaObject': string[];
+};
+export default _default;

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

@@ -0,0 +1,27 @@
+const t = {
+  "metaStateRestful.getMetaState": ["GET", "/患者/服务/元/{id}"],
+  "metaStateRestful.putMetaState": ["PUT", "/患者/服务/元/{id}"],
+  "metaStateRestful.deleteMetaState": ["DELETE", "/患者/服务/元/{id}"],
+  "patientStateRestful.getPatientState": ["GET", "/患者/服务/{id}"],
+  "patientStateRestful.putPatientState": ["PUT", "/患者/服务/{id}"],
+  "patientStateRestful.deletePatientState": ["DELETE", "/患者/服务/{id}"],
+  "patientStateRestful.queryPatientState": ["GET", "/患者/服务"],
+  "patientStateRestful.postPatientState": ["POST", "/患者/服务"],
+  "patientStateRestful.queryPatientStateByExactMatch": ["POST", "/患者/服务/精确匹配"],
+  "metaStateRestful.postMetaState": ["POST", "/患者/服务/元"],
+  "metaStateRestful.queryMetaAndPatientState": ["POST", "/患者/服务/元/级联查询"],
+  "metaStateRestful.queryMetaStateByExactMatch": ["POST", "/患者/服务/元/精确匹配"],
+  "metaStateRestful.queryMetaState": ["POST", "/患者/服务/元/条件查询"],
+  "metricRestful.totalOfPatient": ["GET", "/患者/服务/统计/患者/总数"],
+  "metricRestful.ageDistributeOfPatient": ["GET", "/患者/服务/统计/患者/性别/分布"],
+  "metricRestful.genderDistributeOfPatient": ["GET", "/患者/服务/统计/患者/年龄/分布"],
+  "metricRestful.dateDistributeOfPatient": ["GET", "/患者/服务/统计/患者/分布"],
+  "metricRestful.totalOfPatientByToday": ["GET", "/患者/服务/统计/患者/今日"],
+  "metricRestful.datesOfMeta": ["GET", "/患者/服务/统计/元/日期"],
+  "metricRestful.totalOfMeta": ["GET", "/患者/服务/统计/元/总数"],
+  "metricRestful.totalOfMetaByToday": ["GET", "/患者/服务/统计/元/今日"],
+  "metaStateRestful.getMetaObject": ["GET", "/患者/服务/元/{id}/元象"]
+};
+export {
+  t as default
+};

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

@@ -0,0 +1,10 @@
+import { Alova, AlovaGenerics, AlovaMethodCreateConfig } from 'alova';
+export declare const createApis: (alovaInstance: Alova<AlovaGenerics>, configMap: any) => patientApi;
+export declare const mountApis: (Apis: patientApi) => 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 patientApi ? Url extends keyof patientApi[Tag] ? patientApi[Tag][Url] extends (...args: any) => any ? Parameters<patientApi[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/patient/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, n, i) => {
+  const e = t.join(".");
+  if (l[e])
+    return l[e];
+  const r = new Proxy(function() {
+  }, {
+    get(d, m) {
+      const s = [...t, m];
+      return h(s, n, 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(),
+        n,
+        b,
+        a,
+        o
+      );
+    }
+  });
+  return l[e] = r, r;
+}, x = (t, n) => new Proxy({}, {
+  get(e, r) {
+    return h([r], t, n);
+  }
+}), D = (t) => {
+  globalThis.patientApi = t;
+}, C = (t) => t;
+export {
+  x as createApis,
+  D as mountApis,
+  C as withConfigType
+};

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

@@ -0,0 +1,113 @@
+import { MetaState } from '../globals';
+import { AppendixMeta, ComplaintMeta, ECGMeta, FaceMeta, Meta, Metas, PCGMeta, PPGMeta, PulsationMeta, SceneMeta, TongueMeta } from '../../meta';
+import { Page, Tag } from '../../core';
+import { Patient } from '../../patient';
+export declare class AlovaMeta extends Meta {
+    deserialize(): Promise<this>;
+    inject(): Promise<this>;
+    serialize(): ArrayBuffer;
+    getObject(): Promise<string>;
+    get(): Promise<this>;
+    put(): Promise<this>;
+    post(): Promise<this>;
+    delete(): Promise<this>;
+    analyze(): Promise<this>;
+    static queryMetaWithPatient(page: number, pageSize: number, owner?: Patient, type?: string, startTime?: string, endTime?: string, sort?: string, patientName?: string, patientPhoneNumber?: string, patientStartBirthdate?: string, patientEndBirthdate?: string, patientGender?: string, tags?: Tag[]): Promise<Page<Meta>>;
+    static query(page: number, pageSize: number, owner?: Patient, type?: string, startTime?: string, endTime?: string, sort?: string): Promise<Page<Meta>>;
+    static queryMetaStateByExactMatch(id?: string[], owner?: Patient[], type?: string[], pageSize?: number, page?: number, startTime?: string, endTime?: string, sort?: string): Promise<Page<Meta>>;
+}
+export declare class AlovaTongueMeta extends TongueMeta {
+    getObject(): Promise<string>;
+    get(): Promise<this>;
+    put(): Promise<this>;
+    post(): Promise<this>;
+    delete(): Promise<this>;
+    analyze(overwrite?: boolean): Promise<this>;
+}
+export declare class AlovaFaceMeta extends FaceMeta {
+    getObject(): Promise<string>;
+    post(): Promise<this>;
+    get(): Promise<this>;
+    put(): Promise<this>;
+    delete(): Promise<this>;
+    analyze(overwrite?: boolean): Promise<this>;
+}
+export declare class AlovaSceneMeta extends SceneMeta {
+    getObject(): Promise<string>;
+    post(): Promise<this>;
+    get(): Promise<this>;
+    put(): Promise<this>;
+    delete(): Promise<this>;
+    analyze(overwrite?: boolean): Promise<this>;
+}
+export declare class AlovaPulsationMeta extends PulsationMeta {
+    getObject(): Promise<import('../../../..').WaveMap>;
+    post(): Promise<this>;
+    get(): Promise<this>;
+    put(): Promise<this>;
+    delete(): Promise<this>;
+    analyze(overwrite?: boolean): Promise<this>;
+    preprocess(origins: {
+        [key: string]: number[];
+    }): Promise<{
+        [key: string]: number[];
+    }>;
+}
+export declare class AlovaPPGMeta extends PPGMeta {
+    getObject(): Promise<import('../../../..').WaveMap>;
+    post(): Promise<this>;
+    get(): Promise<this>;
+    put(): Promise<this>;
+    delete(): Promise<this>;
+    analyze(overwrite?: boolean): Promise<this>;
+    preprocess(origins: {
+        [key: string]: number[];
+    }): Promise<{
+        [key: string]: number[];
+    }>;
+}
+export declare class AlovaPCGMeta extends PCGMeta {
+    getObject(): Promise<import('../../../..').WaveMap>;
+    post(): Promise<this>;
+    get(): Promise<this>;
+    put(): Promise<this>;
+    delete(): Promise<this>;
+    analyze(overwrite?: boolean): Promise<this>;
+    preprocess(origins: {
+        [key: string]: number[];
+    }): Promise<{
+        [key: string]: number[];
+    }>;
+}
+export declare class AlovaECGMeta extends ECGMeta {
+    getObject(): Promise<import('../../../..').WaveMap>;
+    post(): Promise<this>;
+    get(): Promise<this>;
+    put(): Promise<this>;
+    delete(): Promise<this>;
+    analyze(overwrite?: boolean): Promise<this>;
+    preprocess(origins: {
+        [key: string]: number[];
+    }): Promise<{
+        [key: string]: number[];
+    }>;
+}
+export declare class AlovaAppendixMeta extends AppendixMeta {
+    getObject(): Promise<string[]>;
+    post(): Promise<this>;
+    get(): Promise<this>;
+    put(): Promise<this>;
+    delete(): Promise<this>;
+    analyze(overwrite?: boolean): Promise<this>;
+}
+export declare class AlovaComplaintMeta extends ComplaintMeta {
+    getObject(): Promise<string>;
+    post(): Promise<this>;
+    get(): Promise<this>;
+    put(): Promise<this>;
+    delete(): Promise<this>;
+    analyze(overwrite?: boolean): Promise<this>;
+}
+export declare class AlovaMetas extends Metas {
+    static map(meta: MetaState): Promise<AlovaPulsationMeta> | Promise<AlovaTongueMeta> | Promise<AlovaComplaintMeta> | Promise<AlovaAppendixMeta> | Promise<AlovaMeta>;
+}