web-core-tcm 0.0.25 → 0.0.27

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

@@ -0,0 +1,27 @@
+import { Check, Payment } from '../../check';
+export declare class AlovaCheck extends Check {
+    get(): Promise<this>;
+    put(): Promise<this>;
+    post(): Promise<this>;
+    delete(): Promise<void>;
+    static query(page: number, pageSize: number, sort: string, patientId?: string, doctorId?: string, startTime?: string, endTime?: string, patientName?: string, patientGender?: string, patientPhoneNumber?: string): Promise<{
+        data: AlovaCheck[];
+        total: number;
+        page: number;
+        pageSize: number;
+        pageCount: number;
+        isLastPage: boolean;
+    }>;
+    static queryPayment(page: number, pageSize: number, doctorId?: string, patientId?: string, patientName?: string, patientPhone?: string, prescriptionPaymentStatus?: number, outboundStatus?: number): Promise<{
+        data: AlovaPayment[];
+        total: number;
+        page: number;
+        pageSize: number;
+        pageCount: number;
+        isLastPage: boolean;
+    }>;
+}
+export declare class AlovaPayment extends Payment {
+    putOutboundStatus(status: number): Promise<this>;
+    putPrescriptionPaymentStatus(status: number): Promise<this>;
+}

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

@@ -0,0 +1,119 @@
+import { Check as d, Payment as m } from "../../check.js";
+class l extends d {
+  async get() {
+    return this.of(
+      await checkApi.checkStateRestful.getCheckState({
+        pathParams: {
+          id: this.id
+        },
+        async transform(t) {
+          return new l().of(t);
+        }
+      }).send()
+    );
+  }
+  async put() {
+    return this.of(
+      await checkApi.checkStateRestful.putCheckState({
+        pathParams: {
+          id: this.id
+        },
+        data: this.state()
+      }).send(!0)
+    );
+  }
+  async post() {
+    return this.of(
+      await checkApi.checkStateRestful.postCheckState({
+        data: this.state()
+      }).send(!0)
+    );
+  }
+  delete() {
+    return checkApi.checkStateRestful.deleteCheckState({
+      pathParams: {
+        id: this.id
+      }
+    }).send(), Promise.resolve();
+  }
+  static query(t, h, u, s, c, i, r, n, e, o) {
+    return checkApi.checkStateRestful.queryCheckState({
+      params: {
+        ...s && { patientId: s },
+        ...c && { doctorId: c },
+        ...i && { startTime: i },
+        ...r && { endTime: r },
+        ...n && { patientName: n },
+        ...e && { patientGender: e },
+        ...o && { patientPhoneNumber: o },
+        pageSize: h,
+        page: t,
+        sort: u
+      },
+      async transform(a) {
+        return {
+          data: await Promise.all(
+            a.content.map((p) => new l().of(p))
+          ),
+          total: a.totalElements,
+          page: a.number,
+          pageSize: a.size,
+          pageCount: a.totalPages,
+          isLastPage: a.last
+        };
+      }
+    }).send();
+  }
+  static queryPayment(t, h, u, s, c, i, r, n) {
+    return checkApi.checkStateRestful.queryPaymentState({
+      params: {
+        ...u && { doctorId: u },
+        ...s && { patientId: s },
+        ...c && { patientName: c },
+        ...i && { patientPhone: i },
+        ...r && { prescriptionPaymentStatus: r },
+        ...n && { outboundStatus: n },
+        pageSize: h,
+        page: t
+      },
+      async transform(e) {
+        return {
+          data: await Promise.all(
+            e.content.map((a) => new k().of(a))
+          ),
+          total: e.totalElements,
+          page: e.number,
+          pageSize: e.size,
+          pageCount: e.totalPages,
+          isLastPage: e.last
+        };
+      }
+    }).send();
+  }
+}
+class k extends m {
+  async putOutboundStatus(t) {
+    return this.outboundStatus = t, await checkApi.checkStateRestful.putCheckState({
+      pathParams: {
+        id: this.id
+      },
+      data: {
+        outboundStatus: t
+      }
+    }).send(!0), Promise.resolve(this);
+  }
+  async putPrescriptionPaymentStatus(t) {
+    return this.prescriptionPaymentStatus = t, await checkApi.checkStateRestful.putCheckState({
+      pathParams: {
+        id: this.id
+      },
+      data: {
+        prescriptionPaymentStatus: t
+      }
+    }).send(!0), Promise.resolve(this);
+  }
+}
+export {
+  l as AlovaCheck,
+  k as AlovaPayment
+};

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

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

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

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

@@ -0,0 +1,54 @@
+import { Patient } from '../patient/patient';
+import { Page, Tag, NetworkObject, Sequence } from '../patient/core';
+import { CheckState, PaymentState } from './alova/globals';
+import { Metas } from '../patient/meta';
+import { Prescription } from '../prescription/prescription';
+import { Doctor } from '../doctor/doctor';
+import { IBuilder } from 'builder-pattern';
+export declare abstract class Check extends NetworkObject {
+    static builder(): IBuilder<Check>;
+    static default(): typeof Check;
+    id: string;
+    doctor: Doctor;
+    patient: Patient;
+    diagnosis: string;
+    tags: Tag[];
+    prescriptions: Sequence<Prescription>;
+    createdTimestamp: string;
+    updatedTimestamp: string;
+    prescriptionPaymentStatus: number;
+    outboundStatus: number;
+    paymentType: string;
+    outpatientType: string;
+    draft: boolean;
+    isEditing: boolean;
+    metas: Metas;
+    constructor();
+    of(json: CheckState): Promise<this>;
+    state(): CheckState;
+    abstract get(): Promise<this>;
+    abstract put(): Promise<this>;
+    abstract post(): Promise<this>;
+    abstract delete(): Promise<void>;
+    static query(page: number, pageSize: number, sort: string, patientId?: string, doctorId?: string, startTime?: string, endTime?: string, patientName?: string, patientGender?: string, patientPhoneNumber?: string): Promise<Page<Check>>;
+    static queryPayment(page: number, pageSize: number, doctorId?: string, patientId?: string, patientName?: string, patientPhone?: string, prescriptionPaymentStatus?: number, outboundStatus?: number): Promise<Page<Payment>>;
+}
+export declare abstract class Payment extends NetworkObject {
+    static builder(): IBuilder<Payment>;
+    static default(): typeof Payment;
+    id: string;
+    prescription: string;
+    doctorId: string;
+    patientId: string;
+    patientName: string;
+    patientPhone: string;
+    patientGender: string;
+    createdTimestamp: number;
+    updatedTimestamp: number;
+    prescriptionPaymentStatus: number;
+    outboundStatus: number;
+    of(json: PaymentState): Promise<this>;
+    state(): PaymentState;
+    abstract putOutboundStatus(status: number): Promise<this>;
+    abstract putPrescriptionPaymentStatus(status: number): Promise<this>;
+}

package/dist/src/api/check/check.js

@@ -0,0 +1,131 @@
+import { Patient as S } from "../patient/patient.js";
+import { NetworkObject as h, Sequence as m, Tag as y } from "../patient/core.js";
+import { Metas as n } from "../patient/meta.js";
+import { Prescription as u } from "../prescription/prescription.js";
+import { AlovaPrescription as g } from "../prescription/alova/implement/prescription.js";
+import { extractPlainText as c } from "../../util/RichTextUtil.js";
+import { Doctor as b } from "../doctor/doctor.js";
+import { Herbal as P } from "../prescription/herbal.js";
+import "../prescription/alova/index.js";
+import { Builder as l } from "../../../node_modules/builder-pattern/dist/index.js";
+class o extends h {
+  static builder() {
+    return l(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  id = "";
+  doctor = b.builder().build();
+  patient = S.builder().build();
+  diagnosis = "";
+  tags = [];
+  prescriptions = new m();
+  createdTimestamp = Date.now().toString();
+  updatedTimestamp = Date.now().toString();
+  prescriptionPaymentStatus = 0;
+  outboundStatus = 0;
+  //购买类型
+  paymentType = "医保";
+  //就诊方式
+  outpatientType = "预约";
+  draft = !1;
+  isEditing = !1;
+  metas = n.builder().build();
+  constructor() {
+    super();
+    const t = u.builder().build();
+    t.herbals.push(P.builder().build()), this.prescriptions.data.push(t);
+  }
+  async of(t) {
+    if (t.tagsState != null && (this.tags = await Promise.all(
+      t.tagsState.map((i) => new y().of(i))
+    )), t.id != null && (this.id = t.id), t.prescriptionsState != null) {
+      this.prescriptions = new m();
+      const i = JSON.parse(t.prescriptionsState), e = await Promise.all(
+        i.map(async (a) => new g().of(a))
+      );
+      this.prescriptions.data.push(...e);
+    }
+    return this.prescriptions.data.length === 0 && this.prescriptions.data.push(u.builder().build()), t.diagnosis != null && (t.diagnosis.indexOf("脉证") !== 0 && t.diagnosis.indexOf(`
+脉证`) === -1 && (t.diagnosis = t.diagnosis.replaceAll("脉证", `
+脉证`)), t.diagnosis.indexOf(`
+方证`) === -1 && (t.diagnosis = t.diagnosis.replaceAll("方证", `
+方证`)), this.diagnosis = c(t.diagnosis)), t.doctorState != null && (this.doctor = await this.doctor.of(t.doctorState)), t.patientState != null && (this.patient = await this.patient.of(t.patientState)), t.createdTimestamp != null && (this.createdTimestamp = t.createdTimestamp), t.updatedTimestamp != null && (this.updatedTimestamp = t.updatedTimestamp), t.prescriptionPaymentStatus != null && (this.prescriptionPaymentStatus = t.prescriptionPaymentStatus), t.outboundStatus != null && (this.outboundStatus = t.outboundStatus), t.paymentType != null && (this.paymentType = t.paymentType), t.outpatientType != null && (this.outpatientType = t.outpatientType), t.metasState != null && this.metas.addMetas(await Promise.all(t.metasState.map((i) => n.map(i)))), this;
+  }
+  state() {
+    console.log(this);
+    const t = {};
+    return t.id = this.id, t.doctorState = this.doctor.state(), t.patientState = this.patient.state(), t.outpatientType = this.outpatientType, t.paymentType = this.paymentType, t.diagnosis = c(this.diagnosis.replace("</div>", `
+<div>`)), t.createdTimestamp = this.createdTimestamp, t.diagnosis = this.diagnosis, t.tagsState = this.tags.map((i) => i.state()), t.createdTimestamp = this.createdTimestamp, t.updatedTimestamp = this.updatedTimestamp, t.prescriptionsState = JSON.stringify(this.prescriptions.data.map((i) => i.state())), t.metasState = n.standards().flatMap(
+      (i) => this.metas[i].data.map((e) => e.state())
+    ), t;
+  }
+  static query(t, i, e, a, s, p, r, d, f, T) {
+    return o.default().query(
+      t,
+      i,
+      e,
+      a,
+      s,
+      p,
+      r,
+      d,
+      f,
+      T
+    );
+  }
+  static queryPayment(t, i, e, a, s, p, r, d) {
+    return o.default().queryPayment(
+      t,
+      i,
+      e,
+      a,
+      s,
+      p,
+      r,
+      d
+    );
+  }
+}
+class J extends h {
+  static builder() {
+    return l(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  id = "";
+  prescription = "";
+  doctorId = "";
+  patientId = "";
+  patientName = "";
+  patientPhone = "";
+  patientGender = "";
+  createdTimestamp = 0;
+  updatedTimestamp = 0;
+  prescriptionPaymentStatus = 0;
+  outboundStatus = 0;
+  async of(t) {
+    return this.id = t.id, this.prescription = t.prescription ? t.prescription : "", this.doctorId = t.doctorId, this.patientId = t.patientId, this.patientName = t.patientName ? t.patientName : "", this.patientPhone = t.patientPhone ? t.patientPhone : "", this.patientGender = t.patientGender ? t.patientGender : "", this.createdTimestamp = t.createdTimestamp ? t.createdTimestamp : 0, this.updatedTimestamp = t.updatedTimestamp ? t.updatedTimestamp : 0, this.prescriptionPaymentStatus = t.prescriptionPaymentStatus ? t.prescriptionPaymentStatus : 0, this.outboundStatus = t.outboundStatus ? t.outboundStatus : 0, Promise.resolve(this);
+  }
+  state() {
+    return {
+      id: this.id,
+      prescription: this.prescription,
+      doctorId: this.doctorId,
+      patientId: this.patientId,
+      patientName: this.patientName,
+      patientPhone: this.patientPhone,
+      patientGender: this.patientGender,
+      createdTimestamp: this.createdTimestamp,
+      updatedTimestamp: this.updatedTimestamp,
+      prescriptionPaymentStatus: this.prescriptionPaymentStatus,
+      outboundStatus: this.outboundStatus
+    };
+  }
+}
+export {
+  o as Check,
+  J as Payment
+};

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

@@ -0,0 +1,11 @@
+import { Check as a, Payment as r } from "./check.js";
+import { $$userConfigMap as m, alovaInstance as n } from "./alova/index.js";
+import { AlovaCheck as p, AlovaPayment as c } from "./alova/implement/check.js";
+export {
+  m as $$userConfigMap,
+  p as AlovaCheck,
+  c as AlovaPayment,
+  a as Check,
+  r as Payment,
+  n as alovaInstance
+};

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

@@ -0,0 +1,5 @@
+import { Method } from 'alova';
+export declare const onAuthRequired: import('alova/client').BeforeRequestType<import('alova').StatesHook<any>, import('alova/fetch').FetchRequestAdapter>;
+export declare const responded: {
+    onSuccess: (response: Response, method: Method) => Promise<any>;
+};

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

@@ -0,0 +1,55 @@
+import { createClientTokenAuthentication as n } from "../../../../node_modules/alova/dist/clienthook/index.esm.js";
+import { storageHelper as e } from "../../../util/helper.js";
+import { jwtDecode as i } from "../../../../node_modules/jwt-decode/build/esm/index.js";
+const { onAuthRequired: u } = n({
+  assignToken: (t) => {
+    e.getItem("token") && (t.config.headers.Authorization = "Bearer " + e.getItem("token"));
+  },
+  visitorMeta: {
+    isVisitor: !0
+  },
+  login: {
+    metaMatches: {
+      login: !0
+    },
+    handler: async (t) => {
+      if (t.status != 200) throw new Error("登录失败" + await t.text());
+      await t.json().then((r) => {
+        e.setItem("token", r.token);
+      });
+    }
+  },
+  refreshToken: {
+    // 在请求前触发，将接收到method参数，并返回boolean表示token是否过期
+    isExpired: () => {
+      if (!e.getItem("token")) return !1;
+      const t = i(e.getItem("token"));
+      if (t.exp === void 0) return !1;
+      const r = Date.now() / 1e3;
+      return t.exp < r;
+    },
+    // 当token过期时触发，在此函数中触发刷新token
+    handler: async () => (e.removeItem("token"), window.location.href = "登录", await Promise.resolve())
+  }
+}), m = {
+  onSuccess: async (t, r) => {
+    if (t.status == 401) {
+      if (r.meta.Login)
+        throw new Error(t.status.toString());
+      console.log("未登录"), e.removeItem("token"), window.location.href = process.env.APP_URL;
+    }
+    if (t.headers.get("Content-Type") == "application/octet-stream") return t;
+    if (t.status == 200 || t.status == 201 || t.status == 204) {
+      const o = await t.text();
+      try {
+        return JSON.parse(o);
+      } catch {
+        return o;
+      }
+    }
+  }
+};
+export {
+  u as onAuthRequired,
+  m as responded
+};

package/dist/src/api/config/index.d.ts

@@ -0,0 +1,23 @@
+export declare enum ServiceType {
+    OAuth = "OAuth",
+    OAuthRedirect = "OAuthRedirect",
+    Doctor = "Doctor",
+    Patient = "Patient",
+    Scientist = "Scientist",
+    Outpatient = "Outpatient",
+    Check = "Check",
+    Prescription = "Prescription",
+    Authorization = "Authorization",
+    InspectionsAlgorithm = "InspectionsAlgorithm",
+    PulsationsAlgorithm = "PulsationsAlgorithm",
+    InquiriesAlgorithm = "InquiriesAlgorithm",
+    LisemsAlgorithm = "LisemsAlgorithm",
+    ComprehensiveAlgorithm = "ComprehensiveAlgorithm"
+}
+export declare enum EnvironmentType {
+    Dev = "Dev",
+    Prod = "Prod",
+    Local = "Local"
+}
+export declare const getServiceEndpoint: (serviceType: ServiceType, env?: EnvironmentType) => "https://用户.仪联中.中国" | "https://用户.仪联中.中国/互联/服务/互联/授权?response_type=code&state=1223&client_id=tcm&scope=profile" | "https://中医.仪联中.中国" | "https://中医.仪联中.中国/望诊/算法" | "https://中医.仪联中.中国/切诊/算法" | "https://中医.仪联中.中国/问诊/算法" | "https://中医.仪联中.中国/闻诊/算法" | "https://中医.仪联中.中国/四诊合参/算法" | "https://用户测试.仪联中.中国" | "https://用户测试.仪联中.中国/互联/服务/互联/授权?response_type=code&state=1223&client_id=tcm&scope=profile" | "https://中医测试.仪联中.中国" | "https://中医测试.仪联中.中国/望诊/算法" | "https://中医测试.仪联中.中国/切诊/算法" | "https://中医测试.仪联中.中国/问诊/算法" | "https://中医测试.仪联中.中国/闻诊/算法" | "https://中医测试.仪联中.中国/四诊合参/算法" | "http://localhost:8080";
+export * from './alova';

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

@@ -0,0 +1,106 @@
+import r from "../../../node_modules/punycode/punycode.es6.js";
+import { onAuthRequired as a, responded as u } from "./alova/index.js";
+var e = /* @__PURE__ */ ((t) => (t.OAuth = "OAuth", t.OAuthRedirect = "OAuthRedirect", t.Doctor = "Doctor", t.Patient = "Patient", t.Scientist = "Scientist", t.Outpatient = "Outpatient", t.Check = "Check", t.Prescription = "Prescription", t.Authorization = "Authorization", t.InspectionsAlgorithm = "InspectionsAlgorithm", t.PulsationsAlgorithm = "PulsationsAlgorithm", t.InquiriesAlgorithm = "InquiriesAlgorithm", t.LisemsAlgorithm = "LisemsAlgorithm", t.ComprehensiveAlgorithm = "ComprehensiveAlgorithm", t))(e || {}), o = /* @__PURE__ */ ((t) => (t.Dev = "Dev", t.Prod = "Prod", t.Local = "Local", t))(o || {});
+const h = (t, s) => {
+  if (s == null && (r.toUnicode(window.location.hostname).includes("测试") ? s = "Dev" : (window.location.hostname.includes("localhost") || window.location.hostname.includes("127.0.0.1"), s = "Prod")), s == "Prod")
+    switch (t) {
+      case "OAuth":
+        return "https://用户.仪联中.中国";
+      case "OAuthRedirect":
+        return "https://用户.仪联中.中国/互联/服务/互联/授权?response_type=code&state=1223&client_id=tcm&scope=profile";
+      case "Doctor":
+        return "https://中医.仪联中.中国";
+      case "Patient":
+        return "https://中医.仪联中.中国";
+      case "Scientist":
+        return "https://中医.仪联中.中国";
+      case "Outpatient":
+        return "https://中医.仪联中.中国";
+      case "Check":
+        return "https://中医.仪联中.中国";
+      case "Prescription":
+        return "https://中医.仪联中.中国";
+      case "Authorization":
+        return "https://中医.仪联中.中国";
+      case "InspectionsAlgorithm":
+        return "https://中医.仪联中.中国/望诊/算法";
+      case "PulsationsAlgorithm":
+        return "https://中医.仪联中.中国/切诊/算法";
+      case "InquiriesAlgorithm":
+        return "https://中医.仪联中.中国/问诊/算法";
+      case "LisemsAlgorithm":
+        return "https://中医.仪联中.中国/闻诊/算法";
+      case "ComprehensiveAlgorithm":
+        return "https://中医.仪联中.中国/四诊合参/算法";
+    }
+  else if (s == "Dev")
+    switch (t) {
+      case "OAuth":
+        return "https://用户测试.仪联中.中国";
+      case "OAuthRedirect":
+        return "https://用户测试.仪联中.中国/互联/服务/互联/授权?response_type=code&state=1223&client_id=tcm&scope=profile";
+      case "Doctor":
+        return "https://中医测试.仪联中.中国";
+      case "Patient":
+        return "https://中医测试.仪联中.中国";
+      case "Scientist":
+        return "https://中医测试.仪联中.中国";
+      case "Outpatient":
+        return "https://中医测试.仪联中.中国";
+      case "Check":
+        return "https://中医测试.仪联中.中国";
+      case "Prescription":
+        return "https://中医测试.仪联中.中国";
+      case "Authorization":
+        return "https://中医测试.仪联中.中国";
+      case "InspectionsAlgorithm":
+        return "https://中医测试.仪联中.中国/望诊/算法";
+      case "PulsationsAlgorithm":
+        return "https://中医测试.仪联中.中国/切诊/算法";
+      case "InquiriesAlgorithm":
+        return "https://中医测试.仪联中.中国/问诊/算法";
+      case "LisemsAlgorithm":
+        return "https://中医测试.仪联中.中国/闻诊/算法";
+      case "ComprehensiveAlgorithm":
+        return "https://中医测试.仪联中.中国/四诊合参/算法";
+    }
+  else if (s == "Local")
+    switch (t) {
+      case "OAuth":
+        return "http://localhost:8080";
+      case "OAuthRedirect":
+        return "https://用户.仪联中.中国/互联/服务/互联/授权?response_type=code&state=1223&client_id=tcm&scope=profile";
+      case "Doctor":
+        return "http://localhost:8080";
+      case "Patient":
+        return "http://localhost:8080";
+      case "Scientist":
+        return "http://localhost:8080";
+      case "Outpatient":
+        return "http://localhost:8080";
+      case "Check":
+        return "http://localhost:8080";
+      case "Prescription":
+        return "http://localhost:8080";
+      case "Authorization":
+        return "http://localhost:8080";
+      case "InspectionsAlgorithm":
+        return "http://localhost:8080";
+      case "PulsationsAlgorithm":
+        return "http://localhost:8080";
+      case "InquiriesAlgorithm":
+        return "http://localhost:8080";
+      case "LisemsAlgorithm":
+        return "http://localhost:8080";
+      case "ComprehensiveAlgorithm":
+        return "http://localhost:8080";
+    }
+  throw new Error("环境错误");
+};
+export {
+  o as EnvironmentType,
+  e as ServiceType,
+  h as getServiceEndpoint,
+  a as onAuthRequired,
+  u as responded
+};

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

@@ -0,0 +1,5 @@
+export function connectToSerialPort(): Promise<boolean>;
+export function getPortInfo(): any;
+export function disconnectToSerialPort(): Promise<void>;
+export function sendText(text: any): Promise<void>;
+export const port: import('vue').Ref<any, any>;

package/dist/src/api/device/device.js

@@ -0,0 +1,46 @@
+import a from "../../../node_modules/quasar/src/composables/use-quasar/use-quasar.js";
+import { ref as n } from "../../../node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+const r = a(), e = n();
+async function s() {
+  try {
+    const o = {
+      baudRate: 115200,
+      dataBits: 8,
+      stopBits: 1,
+      bufferSize: 1024
+    };
+    return e.value = await navigator.serial.requestPort(), e.value ? (await e.value.open(o), console.log("port", e.value.getInfo()), !0) : (r.dialog({
+      title: "错误",
+      message: "未选择串口"
+    }), !1);
+  } catch (o) {
+    return console.error("Error connecting to serial port:", o), r.dialog({
+      title: "错误",
+      message: "连接串口失败"
+    }), !1;
+  }
+}
+function c() {
+  return e.value?.getInfo();
+}
+async function u() {
+  if (!e.value) {
+    console.error("Serial port not available");
+    return;
+  }
+  await e.value.close(), e.value = null, console.log("Serial port disconnected");
+}
+async function f(o) {
+  if (e.value) {
+    const t = e.value.writable.getWriter();
+    console.log("text", o), await t.write(new TextEncoder().encode(o)), await t.close();
+  } else
+    console.error("Serial port not available");
+}
+export {
+  s as connectToSerialPort,
+  u as disconnectToSerialPort,
+  c as getPortInfo,
+  e as port,
+  f as sendText
+};

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

@@ -0,0 +1,26 @@
+/**
+ * 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: {
+    'doctorStateRestful.getDoctorState': string[];
+    'doctorStateRestful.putDoctorState': string[];
+    'doctorStateRestful.deleteDoctorState': string[];
+    'doctorStateRestful.queryDoctorState': string[];
+    'doctorStateRestful.postDoctorState': string[];
+    'doctorStateRestful.queryDoctorStateByExactMatch': string[];
+    'doctorStateRestful.datesOfDoctor': string[];
+    'doctorStateRestful.totalOfDoctor': string[];
+    'doctorStateRestful.totalOfDoctorByToday': string[];
+};
+export default _default;

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

@@ -0,0 +1,14 @@
+const t = {
+  "doctorStateRestful.getDoctorState": ["GET", "/医生/服务/{id}"],
+  "doctorStateRestful.putDoctorState": ["PUT", "/医生/服务/{id}"],
+  "doctorStateRestful.deleteDoctorState": ["DELETE", "/医生/服务/{id}"],
+  "doctorStateRestful.queryDoctorState": ["GET", "/医生/服务"],
+  "doctorStateRestful.postDoctorState": ["POST", "/医生/服务"],
+  "doctorStateRestful.queryDoctorStateByExactMatch": ["POST", "/医生/服务/精确匹配"],
+  "doctorStateRestful.datesOfDoctor": ["GET", "/医生/服务/统计/医生/日期"],
+  "doctorStateRestful.totalOfDoctor": ["GET", "/医生/服务/统计/医生/总数"],
+  "doctorStateRestful.totalOfDoctorByToday": ["GET", "/医生/服务/统计/医生/今日"]
+};
+export {
+  t as default
+};