web-core-tcm 0.0.2 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-core-tcm",
-  "version": "0.0.2",
+  "version": "0.0.7",
   "description": "Core",
   "productName": "Core",
   "author": "wywywywywywywywywy <qa123456_0714@qq.com>",
@@ -40,5 +40,18 @@
     "node": "^28 || ^26 || ^24 || ^22 || ^20",
     "npm": ">= 6.13.4",
     "yarn": ">= 1.21.1"
-  }
+  },
+  "main": "eslint.config.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NUC-TCM/web.core.tcm.git"
+  },
+  "keywords": [
+    "前端核心工具包"
+  ],
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/NUC-TCM/web.core.tcm/issues"
+  },
+  "homepage": "https://github.com/NUC-TCM/web.core.tcm#readme"
 }

package/src/coreApi/api/algorithm/comprehensiveAlgorithm.ts

@@ -0,0 +1,20 @@
+// src/api/comprehensiveAlgorithm.ts
+import { comprehensiveAlgorithmService } from 'src/api/algorithm';
+
+export const comprehensiveQwenAlgorithm = (data: object) =>
+  comprehensiveAlgorithmService.Post<Response>('/千问大模型分析', data, {
+    timeout: 30000,
+  });
+
+export const comprehensiveDeepSeekV3Algorithm = (data: object) =>
+  comprehensiveAlgorithmService.Post<Response>('/DeepSeekV3大模型分析', data, {
+    timeout: 30000,
+  });
+export const comprehensiveDeepSeekR1Algorithm = (data: object) =>
+  comprehensiveAlgorithmService.Post<Response>('/DeepSeekR1大模型分析', data, {
+    timeout: 300000,
+  });
+export const doctorSceneTextAnalysis = (data: object) =>
+  comprehensiveAlgorithmService.Post<Response>('/医生场景文本', data, {
+    timeout: 300000,
+  });

package/src/coreApi/api/algorithm/index.ts

@@ -0,0 +1,44 @@
+import { createAlova } from 'alova';
+import adapterFetch from 'alova/fetch';
+import { responded } from 'src/api/config/alova';
+import { getServiceEndpoint, ServiceType } from 'src/api/config';
+
+export const inspectionAlgorithmService = createAlova({
+  baseURL: getServiceEndpoint(ServiceType.InspectionsAlgorithm),
+  timeout: 30000,
+  cacheFor: null,
+  requestAdapter: adapterFetch(),
+  responded: responded
+});
+
+export const inquiriesAlgorithmService = createAlova({
+  baseURL: getServiceEndpoint(ServiceType.InquiriesAlgorithm),
+  timeout: 30000,
+  cacheFor: null,
+  requestAdapter: adapterFetch(),
+  responded: responded
+});
+
+export const lisemsAlgorithmService = createAlova({
+  baseURL: getServiceEndpoint(ServiceType.LisemsAlgorithm),
+  timeout: 30000,
+  cacheFor: null,
+  requestAdapter: adapterFetch(),
+  responded: responded
+});
+
+export const pulsationsAlgorithmService = createAlova({
+  baseURL: getServiceEndpoint(ServiceType.PulsationsAlgorithm),
+  timeout: 30000,
+  cacheFor: null,
+  requestAdapter: adapterFetch(),
+  responded: responded
+});
+
+export const comprehensiveAlgorithmService = createAlova({
+  baseURL: getServiceEndpoint(ServiceType.ComprehensiveAlgorithm),
+  timeout: 30000,
+  cacheFor: null,
+  requestAdapter: adapterFetch(),
+  responded: responded
+});

package/src/coreApi/api/algorithm/inquiriesAlgorithm.ts

@@ -0,0 +1,19 @@
+import { inquiriesAlgorithmService } from 'src/api/algorithm';
+
+export const complaintsRecognition = (symptomDescription: string) =>
+  inquiriesAlgorithmService.Post<string[]>(
+    '/主诉/识别',
+    { symptomDescription },
+  );
+
+export const complaintsDialog = (body: object) =>
+  inquiriesAlgorithmService.Post<{ reply: string; positive_symptom: string[] }>('/主诉/对话', body);
+
+export const complaintsView = (params: string) =>
+  inquiriesAlgorithmService.Post<{ symptoms: string[] }>('/主诉/视图', {params});
+
+export const complaintsSearch = (data: string) =>
+  inquiriesAlgorithmService.Post<string[]>('/主诉/搜索', {data});
+
+export const complaintsChoose = (body: object) =>
+  inquiriesAlgorithmService.Post<{ status: string; data: [] }>('/主诉/选择', body);

package/src/coreApi/api/algorithm/inspectionsAlgorithm.ts

@@ -0,0 +1,11 @@
+import { inspectionAlgorithmService } from 'src/api/algorithm';
+
+export const tongueAnalyze = (images: FormData) =>
+  inspectionAlgorithmService.Post<JSON>('/舌象', images, {
+    timeout: 30000,
+  });
+
+export const faceAnalyze = (images: FormData) =>
+  inspectionAlgorithmService.Post<JSON>('/面象', images, {
+    timeout: 30000,
+  });

package/src/coreApi/api/algorithm/lisemsAlgorithm.ts

@@ -0,0 +1,16 @@
+import { lisemsAlgorithmService } from 'src/api/algorithm';
+
+export const analysisLisems = (body: object) =>
+  lisemsAlgorithmService.Post<JSON,Response>('/特征参数', body, {
+    transform(data) {
+      return data.json() as Promise<JSON>;
+    },
+  });
+
+export const getFrequencyDomainDiagram = (body: number[]) =>
+  lisemsAlgorithmService.Post<string,Response>('/频域图', JSON.stringify(body), {
+    async transform(res) {
+      const blob = await res.blob();
+      return URL.createObjectURL(blob);
+    },
+  });

package/src/coreApi/api/algorithm/pulsationsAlgorithm.ts

@@ -0,0 +1,9 @@
+import { pulsationsAlgorithmService } from 'src/api/algorithm';
+
+export const pulsationPreprocessing = (pulsation: object) =>
+  pulsationsAlgorithmService.Post<{ [key: string]: number[] }>('/预处理', pulsation, {
+  });
+export const pulsationAnalysis = (pulsation: object) =>
+  pulsationsAlgorithmService.Post<JSON>('/特征参数', pulsation, {
+    timeout: 30000,
+  });

package/src/coreApi/api/authorization/alova/apiDefinitions.ts

@@ -0,0 +1,23 @@
+/// <reference types='./globals.d.ts' />
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * 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.**
+ */
+export default {
+  'oAuthRestful.getToken': ['POST', '/授权/服务/令牌'],
+  'resourceAuthorizationRestful.getResourceAuthorizationState': ['GET', '/授权/服务/资源/{id}'],
+  'roleAuthorizationRestful.getRoleAuthorizationState': ['GET', '/授权/服务/角色/{role}'],
+  'userAuthorizationRestful.getUserAuthorizationState': ['GET', '/授权/服务/用户/{userId}']
+};

package/src/coreApi/api/authorization/alova/createApis.ts

@@ -0,0 +1,99 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * 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.**
+ */
+import type { Alova, MethodType, AlovaGenerics, AlovaMethodCreateConfig } from 'alova';
+import { Method } from 'alova';
+import apiDefinitions from './apiDefinitions';
+
+const cache = Object.create(null);
+const createFunctionalProxy = (array: (string | symbol)[], alovaInstance: Alova<AlovaGenerics>, configMap: any) => {
+  const apiPathKey = array.join('.') as keyof typeof apiDefinitions;
+  if (cache[apiPathKey]) {
+    return cache[apiPathKey];
+  }
+  // create a new proxy instance
+  const proxy = new Proxy(function () {}, {
+    get(_, property) {
+      // record the target property, so that it can get the completed accessing paths
+      const newArray = [...array, property];
+      // always return a new proxy to continue recording accessing paths.
+      return createFunctionalProxy(newArray, alovaInstance, configMap);
+    },
+    apply(_, __, [config]) {
+      const apiItem = apiDefinitions[apiPathKey];
+      if (!apiItem) {
+        throw new Error(`the api path of \`${apiPathKey}\` is not found`);
+      }
+      const mergedConfig = {
+        ...configMap[apiPathKey],
+        ...config
+      };
+      const [method, url] = apiItem;
+      const pathParams = mergedConfig.pathParams;
+      const urlReplaced = url!.replace(/\{([^}]+)\}/g, (_, key) => {
+        const pathParam = pathParams[key];
+        return pathParam;
+      });
+      delete mergedConfig.pathParams;
+      let data = mergedConfig.data;
+      if (Object.prototype.toString.call(data) === '[object Object]' && typeof FormData !== 'undefined') {
+        let hasBlobData = false;
+        const formData = new FormData();
+        for (const key in data) {
+          formData.append(key, data[key]);
+          if (data[key] instanceof Blob) {
+            hasBlobData = true;
+          }
+        }
+        data = hasBlobData ? formData : data;
+      }
+      return new Method(method!.toUpperCase() as MethodType, alovaInstance, urlReplaced, mergedConfig, data);
+    }
+  });
+  cache[apiPathKey] = proxy;
+  return proxy;
+};
+
+export const createApis = (alovaInstance: Alova<AlovaGenerics>, configMap: any) => {
+  const Apis = new Proxy({} as authorizeApi, {
+    get(_, property) {
+      return createFunctionalProxy([property], alovaInstance, configMap);
+    }
+  });
+  return Apis;
+};
+export const mountApis = (Apis: authorizeApi) => {
+  // define global variable `Apis`
+  (globalThis as any).authorizeApi = Apis;
+};
+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 authorizeApi
+  ? Url extends keyof authorizeApi[Tag]
+    ? authorizeApi[Tag][Url] extends (...args: any) => any
+      ? Parameters<authorizeApi[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 const withConfigType = <Config extends MethodsConfigMap>(config: Config) => config;

package/src/coreApi/api/authorization/alova/globals.d.ts

@@ -0,0 +1,373 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * 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.**
+ */
+import type { Alova, AlovaMethodCreateConfig, AlovaGenerics, Method } from 'alova';
+import type { $$userConfigMap, alovaInstance } from './index';
+import type apiDefinitions from './apiDefinitions';
+
+type CollapsedAlova = typeof alovaInstance;
+type UserMethodConfigMap = typeof $$userConfigMap;
+
+type Alova2MethodConfig<Responded> =
+  CollapsedAlova extends Alova<
+    AlovaGenerics<
+      any,
+      any,
+      infer RequestConfig,
+      infer Response,
+      infer ResponseHeader,
+      infer L1Cache,
+      infer L2Cache,
+      infer SE
+    >
+  >
+    ? Omit<
+        AlovaMethodCreateConfig<
+          AlovaGenerics<Responded, any, RequestConfig, Response, ResponseHeader, L1Cache, L2Cache, SE>,
+          any,
+          Responded
+        >,
+        'params'
+      >
+    : never;
+
+// Extract the return type of transform function that define in $$userConfigMap, if it not exists, use the default type.
+type ExtractUserDefinedTransformed<
+  DefinitionKey extends keyof typeof apiDefinitions,
+  Default
+> = DefinitionKey extends keyof UserMethodConfigMap
+  ? UserMethodConfigMap[DefinitionKey]['transform'] extends (...args: any[]) => any
+    ? Awaited<ReturnType<UserMethodConfigMap[DefinitionKey]['transform']>>
+    : Default
+  : Default;
+type Alova2Method<
+  Responded,
+  DefinitionKey extends keyof typeof apiDefinitions,
+  CurrentConfig extends Alova2MethodConfig<any>
+> =
+  CollapsedAlova extends Alova<
+    AlovaGenerics<
+      any,
+      any,
+      infer RequestConfig,
+      infer Response,
+      infer ResponseHeader,
+      infer L1Cache,
+      infer L2Cache,
+      infer SE
+    >
+  >
+    ? Method<
+        AlovaGenerics<
+          CurrentConfig extends undefined
+            ? ExtractUserDefinedTransformed<DefinitionKey, Responded>
+            : CurrentConfig['transform'] extends (...args: any[]) => any
+              ? Awaited<ReturnType<CurrentConfig['transform']>>
+              : ExtractUserDefinedTransformed<DefinitionKey, Responded>,
+          any,
+          RequestConfig,
+          Response,
+          ResponseHeader,
+          L1Cache,
+          L2Cache,
+          SE
+        >
+      >
+    : never;
+
+export interface GetTokenRequest {
+  type?: string;
+  uid?: string;
+  token?: string;
+}
+export interface DoctorState {
+  id?: string;
+  name?: string;
+  createdTimestamp?: number;
+  updatedTimestamp?: number;
+  gender?: string;
+  identityNumber?: string;
+  phoneNumber?: string;
+  birthdate?: string;
+}
+export interface PatientState {
+  id?: string;
+  doctorId?: string;
+  name?: string;
+  createdTimestamp?: number;
+  updatedTimestamp?: number;
+  identity?: string;
+  gender?: string;
+  phoneNumber?: string;
+  birthdate?: string;
+  tags?: string;
+  mainSymptom?: string;
+}
+export interface ScientistState {
+  id?: string;
+  name?: string;
+  createdTimestamp?: number;
+  updatedTimestamp?: number;
+  identityNumber?: string;
+  gender?: string;
+  phoneNumber?: string;
+  birthdate?: string;
+}
+export interface GetTokenResponse {
+  status?: number;
+  token?: string;
+  doctors?: DoctorState[];
+  patients?: PatientState[];
+  scientist?: ScientistState[];
+}
+export interface AuthorizationState {
+  requestDefinition?: string;
+  policyDefinition?: string;
+  policyEffect?: string;
+  matchers?: string;
+  policies?: string;
+}
+export interface ResourceAuthorizationState {
+  resourceId?: string;
+  authorizationStates?: AuthorizationState[];
+  ownerId?: string;
+}
+export interface RoleAuthorizationState {
+  role?: string;
+  authorizationStates?: AuthorizationState[];
+}
+export interface UserAuthorizationState {
+  userId?: string;
+  authorizationStates?: AuthorizationState[];
+}
+declare global {
+  interface authorizeApi {
+    oAuthRestful: {
+      /**
+       * ---
+       *
+       * [POST]
+       *
+       * **path:** /授权/服务/令牌
+       *
+       * ---
+       *
+       * **RequestBody**
+       * ```ts
+       * type RequestBody = {
+       *   type?: string
+       *   uid?: string
+       *   token?: string
+       * }
+       * ```
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = {
+       *   status?: number
+       *   token?: string
+       *   // [items] start
+       *   // [items] end
+       *   doctors?: Array<{
+       *     id?: string
+       *     name?: string
+       *     createdTimestamp?: number
+       *     updatedTimestamp?: number
+       *     gender?: string
+       *     identityNumber?: string
+       *     phoneNumber?: string
+       *     birthdate?: string
+       *   }>
+       *   // [items] start
+       *   // [items] end
+       *   patients?: Array<{
+       *     id?: string
+       *     doctorId?: string
+       *     name?: string
+       *     createdTimestamp?: number
+       *     updatedTimestamp?: number
+       *     identity?: string
+       *     gender?: string
+       *     phoneNumber?: string
+       *     birthdate?: string
+       *     tags?: string
+       *     mainSymptom?: string
+       *   }>
+       *   // [items] start
+       *   // [items] end
+       *   scientist?: Array<{
+       *     id?: string
+       *     name?: string
+       *     createdTimestamp?: number
+       *     updatedTimestamp?: number
+       *     identityNumber?: string
+       *     gender?: string
+       *     phoneNumber?: string
+       *     birthdate?: string
+       *   }>
+       * }
+       * ```
+       */
+      getToken<
+        Config extends Alova2MethodConfig<GetTokenResponse> & {
+          data: GetTokenRequest;
+        }
+      >(
+        config: Config
+      ): Alova2Method<GetTokenResponse, 'oAuthRestful.getToken', Config>;
+    };
+    resourceAuthorizationRestful: {
+      /**
+       * ---
+       *
+       * [GET]
+       *
+       * **path:** /授权/服务/资源/{id}
+       *
+       * ---
+       *
+       * **Path Parameters**
+       * ```ts
+       * type PathParameters = {
+       *   id: string
+       * }
+       * ```
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = {
+       *   resourceId?: string
+       *   // [items] start
+       *   // [items] end
+       *   authorizationStates?: Array<{
+       *     requestDefinition?: string
+       *     policyDefinition?: string
+       *     policyEffect?: string
+       *     matchers?: string
+       *     policies?: string
+       *   }>
+       *   ownerId?: string
+       * }
+       * ```
+       */
+      getResourceAuthorizationState<
+        Config extends Alova2MethodConfig<ResourceAuthorizationState> & {
+          pathParams: {
+            id: string;
+          };
+        }
+      >(
+        config: Config
+      ): Alova2Method<ResourceAuthorizationState, 'resourceAuthorizationRestful.getResourceAuthorizationState', Config>;
+    };
+    roleAuthorizationRestful: {
+      /**
+       * ---
+       *
+       * [GET]
+       *
+       * **path:** /授权/服务/角色/{role}
+       *
+       * ---
+       *
+       * **Path Parameters**
+       * ```ts
+       * type PathParameters = {
+       *   role: string
+       * }
+       * ```
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = {
+       *   role?: string
+       *   // [items] start
+       *   // [items] end
+       *   authorizationStates?: Array<{
+       *     requestDefinition?: string
+       *     policyDefinition?: string
+       *     policyEffect?: string
+       *     matchers?: string
+       *     policies?: string
+       *   }>
+       * }
+       * ```
+       */
+      getRoleAuthorizationState<
+        Config extends Alova2MethodConfig<RoleAuthorizationState> & {
+          pathParams: {
+            role: string;
+          };
+        }
+      >(
+        config: Config
+      ): Alova2Method<RoleAuthorizationState, 'roleAuthorizationRestful.getRoleAuthorizationState', Config>;
+    };
+    userAuthorizationRestful: {
+      /**
+       * ---
+       *
+       * [GET]
+       *
+       * **path:** /授权/服务/用户/{userId}
+       *
+       * ---
+       *
+       * **Path Parameters**
+       * ```ts
+       * type PathParameters = {
+       *   userId: string
+       * }
+       * ```
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = {
+       *   userId?: string
+       *   // [items] start
+       *   // [items] end
+       *   authorizationStates?: Array<{
+       *     requestDefinition?: string
+       *     policyDefinition?: string
+       *     policyEffect?: string
+       *     matchers?: string
+       *     policies?: string
+       *   }>
+       * }
+       * ```
+       */
+      getUserAuthorizationState<
+        Config extends Alova2MethodConfig<UserAuthorizationState> & {
+          pathParams: {
+            userId: string;
+          };
+        }
+      >(
+        config: Config
+      ): Alova2Method<UserAuthorizationState, 'userAuthorizationRestful.getUserAuthorizationState', Config>;
+    };
+  }
+
+  var authorizeApi: authorizeApi;
+}

package/src/coreApi/api/authorization/alova/implement/authorization.ts

@@ -0,0 +1,12 @@
+import { Authorization } from 'src/api/authorization/authorization';
+export class AlovaAuthorization extends Authorization{
+  static override getToken(type?: string, uid?: string, token?: string) {
+    return authorizeApi.oAuthRestful.getToken({
+      data: {
+        ... {... type && {type}},
+        ... {... uid && {uid}},
+        ... {... token && {token}}
+      }
+    }).send()
+  }
+}

package/src/coreApi/api/authorization/alova/index.ts

@@ -0,0 +1,21 @@
+import { createAlova } from 'alova';
+import fetchAdapter from 'alova/fetch';
+import { createApis, withConfigType, mountApis } from './createApis';
+import { onAuthRequired, responded } from 'src/api/config/alova';
+import { getServiceEndpoint, ServiceType } from 'src/api/config';
+
+export const alovaInstance = createAlova({
+  baseURL: getServiceEndpoint(ServiceType.Authorization),
+  requestAdapter: fetchAdapter(),
+  beforeRequest: onAuthRequired(),
+  cacheFor: null,
+  responded: responded
+});
+
+export const $$userConfigMap = withConfigType({});
+
+const Apis = createApis(alovaInstance, $$userConfigMap);
+
+mountApis(Apis);
+
+export default Apis;