@sjcrh/proteinpaint-types 2.78.0-0

package/src/routes/termdb.violin.ts

@@ -0,0 +1,74 @@
+import type { Filter } from '../filter.ts'
+import type { ErrorResponse } from './errorResponse.ts'
+
+export type getViolinRequest = {
+	genome: string
+	dslabel: string
+	embedder: string
+	/** main tw to fetch numeric data to show in violin */
+	tw: any
+	/** optional tw to divide tw data into multiple violins and show under one axis */
+	divideTw?: any
+	/** A number representing the device's pixel ratio, which may be used for rendering quality adjustments */
+	devicePixelRatio: number
+	/** optional mass filter */
+	filter?: Filter
+	/** optional read-only invisible filter TODO GdcFilter0 */
+	filter0?: any
+	/** A number representing the width of the SVG (Scalable Vector Graphics) box, used for rendering the chart */
+	svgw: number
+	/** A string with two possible values: 'horizontal' or 'vertical', indicating the orientation of the chart, either horizontal or vertical */
+	orientation: 'horizontal' | 'vertical'
+	/** A string representing the type of symbol used on the plot, which can be either 'circles' or 'rugs' */
+	datasymbol: string
+	/** A number representing the radius of the data symbols rendered on the plot */
+	radius: number
+	/** A number representing the width of the stroke used to generate the data symbols (data symbols are rendered on the server side) */
+	strokeWidth: number
+	/** A number representing the dimension perpendicular to the violin spread (the height of the axis) */
+	axisHeight: number
+	/** A number representing the right margin of the chart or plot */
+	rightMargin: number
+	/** A string representing a unit of measurement (e.g., 'log' for log scale) */
+	unit: string
+	/** ?? */
+	isKDE: boolean
+}
+
+interface binsEntries {
+	x0: number
+	x1: number
+	density: number
+}
+interface valuesEntries {
+	id: string
+	label: string
+	value: number
+}
+
+interface pvalueEntries {
+	value?: string
+	html?: string
+}
+
+type plot = {
+	label: string
+	plotValueCount: number
+	src: string
+	bins: binsEntries[]
+	densityMax: number
+	biggestBin: number
+	summaryStats: {
+		values: valuesEntries[]
+	}
+}
+
+export type getViolinResponse = ValidResponse | ErrorResponse
+
+type ValidResponse = {
+	min: number
+	max: number
+	plots: plot[]
+	pvalues?: pvalueEntries[][]
+	uncomputableValueObj: any
+}

package/src/routes/wsimages.ts

@@ -0,0 +1,12 @@
+export type GetWSImagesRequest = {
+	genome: string
+	dslabel: string
+	sampleId: string
+	wsimage: string
+}
+
+export type GetWSImagesResponse = {
+	sessionId: string
+	slide_dimensions: number[]
+	status: string
+}

package/src/terms/categorical.ts

@@ -0,0 +1,106 @@
+import {
+	BaseTerm,
+	TermValues,
+	GroupSettingQ,
+	ValuesQ,
+	TermGroupSetting,
+	BaseTW,
+	PredefinedGroupSettingQ,
+	CustomGroupSettingQ
+} from './term.ts'
+import { RawValuesQ, RawPredefinedGroupsetQ, RawCustomGroupsetQ, MinBaseQ } from './q.ts'
+import { TermSettingInstance } from '../termsetting.ts'
+
+/**
+ * A raw categorical term q object, before filling-in
+ *
+ * test:CategoricalQ:
+ *
+ * @category TW
+ */
+
+export type RawCatTWValues = BaseTW & {
+	type?: 'CatTWValues'
+	/** must already exist, for dictionary terms, TwRouter.fill() will use mayHydrateDictTwLst() */
+	term: CategoricalTerm
+	q: RawValuesQ
+}
+
+export type RawCatTWPredefinedGS = BaseTW & {
+	type?: 'CatTWPredefinedGS'
+	term: CategoricalTerm
+	q: RawPredefinedGroupsetQ
+}
+
+export type RawCatTWCustomGS = BaseTW & {
+	type?: 'CatTWCustomGS'
+	term: CategoricalTerm
+	q: RawCustomGroupsetQ
+}
+
+export type RawCatTW = RawCatTWValues | RawCatTWPredefinedGS | RawCatTWCustomGS
+
+export type CategoricalBaseQ = MinBaseQ & {
+	mode?: 'discrete' | 'binary'
+}
+
+export type CategoricalQ = GroupSettingQ | ValuesQ
+
+export type CategoricalTerm = BaseTerm & {
+	type: 'categorical'
+	values: TermValues
+	groupsetting: TermGroupSetting
+}
+
+/**
+ * A categorical term wrapper object
+ *
+ * @group Termdb
+ * @category TW
+ */
+
+export type CategoricalTW = BaseTW & {
+	//id: string
+	type: 'CatTWValues' | 'CatTWPredefinedGS' | 'CatTWCustomGS'
+	q: CategoricalQ
+	term: CategoricalTerm
+}
+
+export type CatTWValues = BaseTW & {
+	//id: string
+	term: CategoricalTerm
+	q: ValuesQ
+	type: 'CatTWValues'
+	// do not use this boolean flag, defined here only to help illustrate
+	// in tw/test/fake/app.js why this is type check error prone and
+	// less preferred than a discriminant prop that also works at runtime
+	isCatTWValues?: true
+}
+
+export type CatTWPredefinedGS = BaseTW & {
+	//id: string
+	term: CategoricalTerm
+	q: PredefinedGroupSettingQ
+	type: 'CatTWPredefinedGS'
+	// do not use this boolean flag, defined here only to help illustrate
+	// in tw/test/fake/app.js why this is type check error prone and
+	// less preferred than a discriminant prop that also works at runtime
+	isCatTWPredefiendGS?: true
+}
+
+export type CatTWCustomGS = BaseTW & {
+	//id: string
+	term: CategoricalTerm
+	q: CustomGroupSettingQ
+	type: 'CatTWCustomGS'
+}
+
+export type CatTWTypes = CatTWValues | CatTWPredefinedGS | CatTWCustomGS
+
+export type CategoricalTermSettingInstance = TermSettingInstance & {
+	q: CategoricalQ
+	term: CategoricalTerm
+	category2samplecount: any
+	validateGroupsetting: () => { text: string; bgcolor?: string }
+	error?: string
+}

package/src/terms/condition.ts

@@ -0,0 +1,55 @@
+import { BaseTerm, BaseQ, TermValues } from './term.ts'
+import { TermWrapper } from './tw.ts'
+
+/**
+ * @category TW
+ */
+
+export type ConditionQ = BaseQ & {
+	mode: 'discrete' | 'binary' | 'cuminc' | 'cox'
+	type?: 'values'
+	bar_by_children?: boolean // 'true' if term is not a leaf and has subconditions
+	bar_by_grade?: boolean /* 'true' for barchart. Always 'true' for cuminc and logistic/cox outcome (children terms are not allowed for those cases)
+	when 'true', 'value_by_*' flags are effective.*/
+	breaks?: number[] /*
+	Breaks grades into groups
+		Array length=1, will break grades to 2 groups. 
+			E.g. [3] divides to [-1,0,1,2,], [3,4,5]
+			Allowed for both conditionModes "discrete/binary"
+		Array length=2, break to 3 groups. 
+			E.g. [1,2] divides to [-1,0], [1], [2,3,4,5]
+			E.g. [1,3] divides to [-1,0], [1,2], [3,4,5]
+			Only allowed for conditionMode="discrete" but not "binary"
+	*/
+	timeScale: 'age' | 'time'
+	value_by_max_grade?: boolean //'false' if bar_by_children is 'true'
+	value_by_most_recent?: boolean //'false' if bar_by_children is 'true'
+	value_by_computable_grade?: boolean //'true' if bar_by_children is 'true'
+	groups?: any // TODO: should use a defined type
+}
+
+export type ConditionTerm = BaseTerm & {
+	type: 'condition'
+	values: TermValues
+}
+
+/**
+ * @group Termdb
+ * @category TW
+ */
+export type ConditionTW = TermWrapper & {
+	term: ConditionTerm
+	q: ConditionQ //replace the generic Q with specific condition Q
+}
+
+/**
+ * @group Termdb
+ * @category TW
+ */
+/*
+export type ConditionTermSettingInstance = TermSettingInstance & {
+	q: ConditionQ
+	category2samplecount: { key: string; label: string; count: number }[]
+	refGrp: any
+}
+*/

package/src/terms/geneExpression.ts

@@ -0,0 +1,32 @@
+import { TermWrapper } from './tw.ts'
+import { NumericTerm, NumericQ } from './numeric.ts'
+import { TermSettingInstance } from '../termsetting.ts'
+
+/*
+--------EXPORTED--------
+GeneExpressionQ
+GeneExpressionTermWrapper
+GeneExpressionTermSettingInstance
+
+*/
+
+export type GeneExpressionQ = NumericQ & { dt?: number }
+
+export type GeneExpressionTW = TermWrapper & {
+	q: GeneExpressionQ
+	term: GeneExpressionTerm
+}
+
+export type GeneExpressionTerm = NumericTerm & {
+	gene: string
+	// temporarily allowing chr/start/stop to support
+	// legacy fpkm files
+	chr?: string
+	start?: number
+	stop?: number
+}
+
+export type GeneExpressionTermSettingInstance = TermSettingInstance & {
+	q: GeneExpressionQ
+	term: GeneExpressionTerm
+}

package/src/terms/geneVariant.ts

@@ -0,0 +1,51 @@
+import { MinBaseQ, BaseTerm, EnabledTermGroupSetting, BaseTW, GroupSettingQ, ValuesQ } from '../index.ts'
+import { TermSettingInstance } from '../termsetting.ts'
+
+export type GeneVariantBaseQ = MinBaseQ & {
+	cnvGainCutoff?: number
+	cnvMaxLength?: number
+	cnvMinAbsValue?: number
+	cnvLossCutoff?: number
+	exclude: string[]
+	dt?: number
+	origin?: string
+}
+
+export type GeneVariantQ = GeneVariantBaseQ & (ValuesQ | GroupSettingQ)
+
+type GeneVariantBaseTerm = BaseTerm & {
+	type: 'geneVariant'
+	groupsetting: EnabledTermGroupSetting
+}
+
+export type GeneVariantGeneTerm = GeneVariantBaseTerm & {
+	kind: 'gene'
+	gene: string
+	// chr,start,stop should exist together as a separate type called
+	// 'Coord', but hard to code as atomic `& Coord` because it may
+	// need to be filled in
+	chr?: string
+	start?: number
+	stop?: number
+}
+
+export type GeneVariantCoordTerm = GeneVariantBaseTerm & {
+	kind: 'coord'
+	chr: string
+	start: number
+	stop: number
+}
+
+export type GeneVariantTerm = GeneVariantGeneTerm | GeneVariantCoordTerm
+
+export type GeneVariantTW = BaseTW & {
+	term: GeneVariantTerm
+	q: GeneVariantQ
+}
+
+export type GeneVariantTermSettingInstance = TermSettingInstance & {
+	q: GeneVariantQ
+	term: GeneVariantTerm
+	category2samplecount: any
+	groupSettingInstance?: any
+}

package/src/terms/metaboliteIntensity.ts

@@ -0,0 +1,31 @@
+import { TermWrapper } from './tw.ts'
+import { BaseQ } from './term.ts'
+import { NumericTerm } from './numeric.ts'
+import { TermSettingInstance } from '../termsetting.ts'
+
+/*
+--------EXPORTED--------
+MetaboliteIntensityQ
+MetaboliteIntensityTermWrapper
+MetaboliteIntensityTermSettingInstance
+
+*/
+
+export type MetaboliteIntensityQ = BaseQ & {
+	mode: 'continuous'
+}
+
+export type MetaboliteIntensityTW = TermWrapper & {
+	q: MetaboliteIntensityQ
+	term: MetaboliteIntensityTerm
+}
+
+export type MetaboliteIntensityTerm = NumericTerm & {
+	metabolite: string
+	bins: any
+}
+
+export type MetaboliteIntensityTermSettingInstance = TermSettingInstance & {
+	q: MetaboliteIntensityQ
+	term: MetaboliteIntensityTerm
+}

package/src/terms/numeric.ts

@@ -0,0 +1,245 @@
+import { MinBaseQ, BaseTW, TermValues, BaseTerm } from '../index.ts'
+
+export type RawRegularBin = Partial<RegularNumericBinConfig> & { preferredBins?: string }
+
+export type RawNumTWRegularBin = BaseTW & {
+	type?: 'NumTWRegularBin'
+	term: NumericTerm
+	q: RawRegularBin
+}
+
+export type RawCustomBin = Partial<CustomNumericBinConfig> & { preferredBins?: string }
+
+export type RawNumTWCustomBin = BaseTW & {
+	type?: 'NumTWCustomBin'
+	term: NumericTerm
+	q: RawCustomBin
+}
+
+export type RawNumTWCont = BaseTW & {
+	type?: 'NumTWCont'
+	term: NumericTerm
+	q: ContinuousNumericQ
+}
+
+export type RawNumTWSpline = BaseTW & {
+	type?: 'NumTWSpline'
+	term: NumericTerm
+	q: SplineNumericQ
+}
+
+export type RawNumTW = RawNumTWCustomBin | RawNumTWRegularBin | RawNumTWCont | RawNumTWSpline
+
+export type NumericTerm = BaseTerm & {
+	id?: string
+	// these concrete term.type values make it clear that only these are numeric,
+	// "categorical", "condition", and other term.types are not included in this union
+	type: 'integer' | 'float' | 'geneExpression' | 'metaboliteIntensity'
+	bins: PresetNumericBins
+	values?: TermValues
+	unit?: string
+	/*densityNotAvailable?: boolean //Not used?
+	logScale?: string | number
+	max?: number
+	min?: number
+	name?: string
+	skip0forPercentile?: boolean
+	tvs?: Tvs
+	values?: TermValues
+	unit?: string
+	valueConversion?: ValueConversion*/
+}
+
+export type StartUnboundedBin = {
+	// where possible, assign a concrete value (true) when it is known in advance,
+	// in which case, do not use an abstract type (boolean) to startunbounded
+	startunbounded: true
+	startinclusive?: false // cannot include an infinite bound
+	stop: number
+	stopinclusive?: boolean
+	stopunbounded?: false
+	label?: string
+}
+
+export type StopUnboundedBin = {
+	start: number
+	stopunbounded: true
+	startinclusive?: boolean
+	startunbounded?: false
+	stopinclusive?: false // cannot include an infinite bound
+	label?: string
+}
+
+// TODO??? should separate a fully bounded bin by startinclusive, stopinclusive
+// since neighboring bins must not contain the same boundary value
+export type FullyBoundedBin = {
+	startunbounded?: false
+	startinclusive?: boolean
+	start: number
+	stop: number
+	stopinclusive?: boolean
+	stopunbounded?: false
+	label?: string
+}
+
+export type NumericBin = StartUnboundedBin | FullyBoundedBin | StopUnboundedBin
+
+export type RegularNumericBinConfig = MinBaseQ & {
+	type: 'regular-bin' // another concrete value being assigned, instead of `string`
+	//regular-sized bins
+	mode?: 'discrete'
+	bin_size: number
+	// first_bin.stop is always required
+	first_bin: StartUnboundedBin | FullyBoundedBin
+
+	// if last_bin?.start is set, then a fixed last bin is used; otherwise it's not fixed and computed from data
+	last_bin?: StopUnboundedBin | FullyBoundedBin
+	label_offset?: number
+}
+
+export type CustomNumericBinConfig = MinBaseQ & {
+	type: 'custom-bin'
+	mode?: 'discrete' | 'binary'
+	// since ts will allow NumericBin[] to be empty,
+	// use this workaround to define a non-empty array
+	lst: [NumericBin, ...NumericBin[]]
+	preferredBins?: 'median'
+}
+
+// |
+// {
+// 	type?: 'custom-bin'
+// 	mode?: 'discrete' | 'binary'
+// 	// since ts will allow NumericBin[] to be empty,
+// 	// use this workaround to define a non-empty array
+// 	lst?: [NumericBin, ...NumericBin[]]
+// }
+
+/*export type NumericQ = BaseQ & {
+	// termType: 'float' | 'integer' -- converts to 'numeric'
+	preferredBins?: 'median' | 'less' | 'default'
+	modeBinaryCutoffType: 'normal' | 'percentile'
+	modeBinaryCutoffPercentile?: number
+	knots?: any //[]?
+	scale?: number //0.1 | 0.01 | 0.001
+	rounding: string
+}*/
+
+export type PresetNumericBins = {
+	default: RegularNumericBinConfig | CustomNumericBinConfig
+	less: RegularNumericBinConfig | CustomNumericBinConfig
+	label_offset?: number
+	label_offset_ignored?: boolean
+	rounding?: string
+	min?: number
+	max?: number
+}
+
+export type BinnedNumericQ = RegularNumericBinConfig | CustomNumericBinConfig
+
+export type DiscreteNumericQ = BinnedNumericQ //&
+// MinBaseQ & {
+// 	mode: 'discrete' | 'binary'
+// }
+
+// TODO: test with live code that defines an actual binary q object
+export type BinaryNumericQ = MinBaseQ & {
+	mode: 'binary'
+	type: 'custom-bin'
+	// tuple type with 2 members
+	lst: [StartUnboundedBin | FullyBoundedBin, StopUnboundedBin | FullyBoundedBin]
+}
+
+export type ContinuousNumericQ = MinBaseQ & {
+	mode: 'continuous'
+	// TODO: do not use a boolean, convert to a `transform: 'zscore' | ...` option
+	convert2ZScore?: boolean
+	//scale?: string
+	// todo below: q.type is expected to be undefined for now,
+	// but may be used later like in other q.modes,
+	// making type optional here makes NumericQ operations/conditions
+	// work consistently within the TermWrapper union type
+	type?: undefined
+}
+
+export type SplineNumericQ = MinBaseQ & {
+	mode: 'spline'
+	knots: {
+		value: number
+	}[]
+	// todo below: q.type is expected to be undefined for now,
+	// but may be used later like in other q.modes,
+	// making type optional here makes NumericQ operations/conditions
+	// work consistently within the TermWrapper union type
+	type?: undefined
+}
+
+export type NumericQ = DiscreteNumericQ | BinaryNumericQ | ContinuousNumericQ | SplineNumericQ
+
+export type NumericTW = BaseTW & {
+	//id: string
+	term: NumericTerm
+	q: NumericQ
+}
+
+export type NumTWDiscrete = BaseTW & {
+	type: 'NumTWDiscrete'
+	term: NumericTerm
+	q: DiscreteNumericQ
+}
+
+export type NumTWRegularBin = BaseTW & {
+	type: 'NumTWRegularBin'
+	term: NumericTerm
+	q: RegularNumericBinConfig
+}
+
+export type NumTWCustomBin = BaseTW & {
+	type: 'NumTWCustomBin'
+	term: NumericTerm
+	q: CustomNumericBinConfig
+}
+
+export type NumTWBinaryBin = BaseTW & {
+	type: 'NumTWBinaryBin'
+	term: NumericTerm
+	q: BinaryNumericQ
+}
+
+export type NumTWBinary = BaseTW & {
+	type: 'NumTWBinary'
+	term: NumericTerm
+	q: BinaryNumericQ
+}
+
+export type NumTWCont = BaseTW & {
+	type: 'NumTWCont'
+	term: NumericTerm
+	q: ContinuousNumericQ
+}
+
+export type NumTWSpline = BaseTW & {
+	type: 'NumTWSpline'
+	term: NumericTerm
+	q: SplineNumericQ
+}
+
+export type NumTWTypes = NumTWRegularBin | NumTWCustomBin | NumTWBinary | NumTWCont | NumTWSpline
+export type NumTWDiscreteTypes = NumTWRegularBin | NumTWCustomBin //| NumTWBinary
+
+export type DefaultMedianQ = {
+	isAtomic?: true
+	mode: 'discrete'
+	type: 'custom-bin'
+	preferredBins: 'median'
+	lst: []
+}
+
+export type DefaultBinnedQ = {
+	isAtomic: true
+	mode: 'discrete'
+	type: 'regular-bin' | 'custom-bin'
+	preferredBins: 'default' | 'less'
+}
+
+export type DefaultNumericQ = NumericQ | DefaultBinnedQ | DefaultMedianQ

package/src/terms/q.ts

@@ -0,0 +1,38 @@
+import { HiddenValues, GroupSettingQ, GroupEntry } from './term.ts'
+
+// MinBaseQ is BaseQ without .mode and .type
+// MinBaseQ should eventually replace BaseQ because .mode and .type
+// should be specified in a term-type-specific manner
+export type MinBaseQ = {
+	/**Automatically set by fillTermWrapper()
+	Applies to barchart, survival plot, and cuminc plot.
+	Contains categories of a term to be hidden in its chart. This should only apply to client-side rendering, and should not be part of “dataName” when requesting data from server. Server will always provide a summary for all categories. It’s up to the client to show/hide categories.
+	This allows the key visibility to be stored in state, while toggling visibility will not trigger data re-request.
+	Currently termsetting menu does not manage this attribute. It’s managed by barchart legend.
+	*/
+	hiddenValues?: HiddenValues
+	/**indicates this object should not be extended by a copy-merge tool */
+	isAtomic?: true
+	name?: string
+	reuseId?: string
+}
+
+export type RawValuesQ = MinBaseQ & { type?: 'values'; mode?: 'binary' }
+
+export type RawPredefinedGroupsetQ = MinBaseQ & {
+	type: 'predefined-groupset'
+	mode?: 'binary' | 'discrete'
+	predefined_groupset_idx: number
+	/** deprecated nested object, will be handled by reshapeLegacyTW() in TwRouter */
+	groupsetting?: { inuse?: boolean } & GroupSettingQ
+}
+
+export type RawCustomGroupsetQ = MinBaseQ & {
+	type: 'custom-groupset'
+	mode?: 'binary' | 'discrete'
+	customset: {
+		groups: GroupEntry[]
+	}
+	/** deprecated nested object, will be handled by reshapeLegacyTW() in TwRouter */
+	groupsetting?: { inuse?: boolean } & GroupSettingQ
+}

package/src/terms/samplelst.ts

@@ -0,0 +1,41 @@
+import { BaseTerm, BaseQ } from './term.ts'
+import { TermWrapper } from './tw.ts'
+import { TermSettingInstance } from '../termsetting.ts'
+
+/*
+--------EXPORTED--------
+SampleLstTermValues
+SampleLstQ
+SampleLstTerm
+SampleLstTW
+SampleLstSettingInstance
+
+*/
+
+export type SampleLstTermValues = {
+	[index: string | number]: {
+		name: string
+		inuse: boolean
+		list: { sampleId: string; sample: string }[]
+		values: any
+	}
+}
+
+export type SampleLstQ = BaseQ & {
+	groups: SampleLstTermValues
+}
+
+export type SampleLstTerm = BaseTerm & {
+	values: SampleLstTermValues
+}
+
+export type SampleLstTW = TermWrapper & {
+	q: SampleLstQ
+	term: SampleLstTerm
+}
+
+//temporary, will eventually change to SampleLstHandler
+export type SampleLstTermSettingInstance = TermSettingInstance & {
+	q: SampleLstQ
+	term: SampleLstTerm
+}