字段定义

╰半橙微兮° 2023-07-11 08:51 13阅读 0赞

export enum Sex {
      Male = 'Male',
      Female = 'Female',
      Other = 'Other'
    }
    
    export interface PersonA {
      __typename: Sex.Male;
      age: number;
    }
    
    export interface PersonB {
      __typename: Sex.Female;
      name: string;
    }

export enum PatientTypes{
      CreateNewPatientStudy='CreateNewPatientStudy'
    }
    
    export const PatientType='Patient' as const;

export const PatientType = "patientConst" as const;
    
    export interface TagID<Id, Tag> {
      readonly id: Id;
      readonly __typename: Tag;
    }
    
    export interface TypedItem<T, Id, D, R> extends TagID<Id, T> {
      data: D;
      relation: R;
    }
    
    export type Patient = TypedItem<
      typeof PatientType,
      string,
      {
        readonly name: string;
        readonly birthday: Date;
        readonly external_id: string;
      },
      {}
    >;
    
    // 联合类型
    
    比如定义一个name, birthday, external_id, __typename的接口，可这样：
    
    export type PatientCerten = Patient['data'] & {__typname: string}

export namespace gantry {
      export enum GantryMessageTypes {
        CTGantryRotateStart = 'CTGantryRotateStart',
        CTGantryRotateStop = 'CTGantryRotateStop',
      }
      export interface CTGantryRotateStart {
        __typename: GantryMessageTypes.CTGantryRotateStart;
        velocity: number;
      }
    
      export interface CTGantryRotateStop {
        __typename: GantryMessageTypes.CTGantryRotateStop;
      }
    }

export namespace status {
      export enum TableStatus {
        Moving = "moving",
        Unlock = "unlock",
      }
    
      export enum Connection {
        Connected = "connected",
        Disconnected = "disconnected",
      }
    }

export type ScoutAngle = 0 | 90 | 180 | 270;
    export const ScoutAngle: ReadonlyArray<ScoutAngle> = [0, 90, 180, 270];

export enum HintMessageTypes {
      ShowExposureHint = 'ShowExposureHint',
      CancelExposureHint = 'CancelExposureHint'
    }
    
    export interface ShowExposureHint {
      __typename: HintMessageTypes.ShowExposureHint;
      event:HintMessageTypes.ShowExposureHint
    }
    export interface CancelExposureHint {
      __typename: HintMessageTypes.CancelExposureHint;
      event:HintMessageTypes.CancelExposureHint
    }
    
    export type CTHintMessage =
      | ShowExposureHint
      | CancelExposureHint;

export const enum ScanTypes {
      ScanAxial = 'ScanAxial',
      ScanPET = 'ScanPET'
    }
    
    export interface ScanAxial {
      name: string;
      direction: Direction;
    }
    export interface ScanPET {
      name: string;
      state: ScanPETState;
    }
    
    export type ScanAxialItem = TypedItem<
      ScanTypes.ScanAxial,
      string,
      ScanAxial,
      ScanRelation
    >;
    export type ScanPETItem = TypedItem<
      ScanTypes.ScanPET,
      string,
      ScanPET,
      ScanRelation
    >;
    
    export interface ScanRelation {
      readonly children_ids: string[];
      readonly container_info?: {
        id: Protocol['id'];
        index: number;
      };
    }

--------------------

_test: string = 'sss';
      set test(e: string) {
        this._test = e;
      }
    
      get test() {
        return this._test;
      }
    
      onStart() {
        const a = this.test;
        console.log(a)
      }
    
    // 打印 sss

function toValue<T extends { value: R }, R>(xs: T[]): R[] {
      return xs.map(x => x.value as R);
    }
    
    interface SelectedFilters {
      focus: Focus[];
      FFS: FFS[];
      location: Region[];
      voltage: TubeVoltage[];
      bowtie: BowtieFilterSize[];
    }
    
      currentSelectedFilters() {
        return {
          focus: toValue<SelectOption<Focus>, Focus>(this.focusSelected),
          FFS: toValue<SelectOption<FFS>, FFS>(this.FFSSelected),
          location: toValue<SelectOption<Region>, Region>(this.locationSelected),
          voltage: toValue<SelectOption<TubeVoltage>, TubeVoltage>(
            this.voltageSelected as SelectOption<TubeVoltage>[]
          ),
          bowtie: toValue<SelectOption<BowtieFilterSize>, BowtieFilterSize>(
            this.bowtieSelected
          )
        };
      }
    
      _selectedFilters: SelectedFilters = this.currentSelectedFilters();
      get bowtieSelected() {
        return this._bowtieSelected;
      }
      set bowtieSelected(value: SelectOption<BowtieFilterSize>[]) {
        this._bowtieSelected = value;
        this.selectedFilters = this.currentSelectedFilters();
      }
    
      onStart() {
        super.onStart('fast');
        const selected = this.selectedFilters;
        const action = {
          __typename: calibration.CalibrationMessageTypes.FastCalibration,
          calibration_type: 'fast',
          air_calibration: {
            ffs: selected.FFS,
            focal_spot_size: selected.focus,
            bowtie: selected.bowtie,
            tube_voltage: selected.voltage
          }
        } as calibration.CTFastCalibration;
        this.service.ctsMachine.calibration.run(action);
    
       console.log(currentSelectedFilters());
      }
    
    // 如果打印currentSelectedFilters()这个函数，截图如下：

![202003091139342.png][]

--------------------

export interface SelectOption<T> {
      value: T;
      shown: string;
    }
    
    // 1
    let a: SelectOption<number> = {
      value: 31313,
      shown: 'sss'
    };
    
    // 2
    const da: SelectOption<{ large: 'large'; small: 'small' }>[] = [
      {
        value: { large: 'large', small: 'small' },
        shown: 'ss'
      },
      {
        value: { large: 'large', small: 'small' },
        shown: 'sssssssssssssss'
      }
    ];
    
    // 3
    export enum Focus {
      large = 'large',
      small = 'small',
    }
    const test: SelectOption<Focus>[] = [
      {
        value: Focus.large,
        shown: 'ss'
      }
    ];

function toValue<T extends { value: R }, R>(xs: T[]): R[] {
      return xs.map(x => x.value as R);
    }
    function x() {
      const test: SelectOption<Focus>[] = [
        {
          value: Focus.large,
          shown: 'ss'
        }
      ];
      return { a: toValue<SelectOption<Focus>, Focus>(test), b: 'ssss' };
    }

interface SelectOption<T> {
      value: T;
      shown: string;
    }
    
    const test1: SelectOption<Focus> = {
      value: Focus.large,
      shown: 'dd'
    };
    
    type Test<T extends { value: any }> = {
      a: T;
      b: string;
    };
    
    const test2: Test<SelectOption<Focus>> = {
      a: { value: Focus.large, shown: 'dd' },
      b: 'dd'
    };

## ##

[202003091139342.png]: https://img-blog.csdnimg.cn/202003091139342.png