@sjcrh/proteinpaint-types 2.84.0 → 2.85.0

package/src/terms/numeric.ts

@@ -1,253 +0,0 @@
-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 NumericDictTerm = BaseTerm & {
-	id?: string
-	type: 'integer' | 'float'
-	bins: PresetNumericBins
-	values?: TermValues
-	unit?: string
-}
-
-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

@@ -1,38 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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
-}

package/src/terms/singleCellCellType.ts

@@ -1,22 +0,0 @@
-import { BaseTerm, BaseTW, GroupSettingQ, TermGroupSetting, TermValues } from './term.ts'
-import { MinBaseQ } from './q.ts'
-
-type SingleCellCellTypeBaseQ = MinBaseQ & { mode: 'discrete' | 'binary' }
-
-export type SingleCellCellTypeQ = SingleCellCellTypeBaseQ & GroupSettingQ
-
-export type SingleCellCellTypeTerm = BaseTerm & {
-	type: 'singleCellCellType'
-	/** the cell types may be also cell attributes like CNV, Fusion, etc */
-	values: TermValues
-	/** single cell terms require a sample to read the term values, they are associated with a sample */
-	sample: string
-	/** the plot defined in the dataset contains a column with the term values for the sample, it needs to be passed to read the sample values */
-	plot: string
-	groupsetting: TermGroupSetting
-}
-
-export type SingleCellCellTypeTW = BaseTW & {
-	term: SingleCellCellTypeTerm
-	q: SingleCellCellTypeQ
-}

package/src/terms/singleCellGeneExpression.ts

@@ -1,28 +0,0 @@
-import { TermWrapper } from './tw.ts'
-import { BaseQ } from './term.ts'
-import { GeneExpressionQ } from './geneExpression.ts'
-import { TermSettingInstance } from '../termsetting.ts'
-import { NumericTerm } from './numeric.ts'
-
-/*
---------EXPORTED--------
-GeneExpressionQ
-GeneExpressionTermWrapper
-GeneExpressionTermSettingInstance
-
-*/
-
-export type SingleCellGeneExpressionTW = TermWrapper & {
-	q: GeneExpressionQ
-	term: SingleCellGeneExpressionTerm
-}
-
-export type SingleCellGeneExpressionTerm = NumericTerm & {
-	gene: string
-	sample: string
-}
-
-export type SingleCellGeneExpressionTermSettingInstance = TermSettingInstance & {
-	q: GeneExpressionQ
-	term: SingleCellGeneExpressionTerm
-}

package/src/terms/snp.ts

@@ -1,28 +0,0 @@
-import { TermWrapper } from './tw.ts'
-import { BaseQ, BaseTerm, GroupSettingQ, TermGroupSetting } from './term.ts'
-import { TermSettingInstance } from '../termsetting.ts'
-
-/*
-For term type 'snp'
-*/
-
-export type SnpQ = BaseQ & GroupSettingQ
-
-export type SnpTW = TermWrapper & {
-	q: SnpQ
-	term: SnpTerm
-}
-
-export type SnpTerm = BaseTerm & {
-	chr: string
-	start: number
-	stop: number
-	ref: string
-	alt: string[]
-	groupsetting: TermGroupSetting
-}
-
-export type SnpTermSettingInstance = TermSettingInstance & {
-	q: SnpQ
-	term: SnpTerm
-}

package/src/terms/snps.ts

@@ -1,110 +0,0 @@
-import { BaseTW, BaseQ, BaseTerm } from './term.ts'
-import { TermSettingInstance, InstanceDom, UseCase } from '../termsetting.ts'
-import { VocabApi } from '../vocab.ts'
-import { Tvs, Filter } from '../filter.ts'
-
-/*
---------EXPORTED--------
-SnpsQ
-SnpsEntry
-SnpsTerm
-SnpsTW
-SnpsVocabApi
-SnpsTermSettingInstance
-
-*/
-
-type RestrictAncestry = {
-	name: string
-	tvs: Tvs
-}
-
-export type SnpsQ = BaseQ & {
-	// termType: 'snplocus' | 'snplst'
-	//for snplst and snplocus term types
-	AFcutoff: number
-	alleleType: number
-	cacheid: string
-	doNotRestrictAncestry: any
-	geneticModel: number
-	info_fields?: any //[] Not documented
-	missingGenotype?: number
-	numOfSampleWithAnyValidGT: number
-	restrictAncestry: RestrictAncestry
-	snp2effAle?: any
-	snp2refGrp: any //[] maybe??
-	variant_filter: Filter
-	//Position
-	chr: string
-	start: number
-	stop: number
-}
-
-type AllelesEntry = {
-	allele: string
-	count: number
-	isRef: boolean
-}
-
-export type SnpsEntry = {
-	alt2csq?: any //{} In document but not implemented?
-	altAlleles?: string[]
-	alleles?: AllelesEntry[]
-	effectAllele: boolean
-	gt2count?: {
-		k: string
-		v: string | number
-	}
-	invalid?: boolean
-	referenceAllele?: string
-	rsid: string
-	snpid: string
-	tobe_deleted?: any
-	//Position properties
-	chr?: string
-	pos?: number
-}
-
-export type SnpsTerm = BaseTerm & {
-	id: string
-	reachedVariantLimit?: boolean
-	snps?: SnpsEntry[]
-}
-
-export type SnpsTW = BaseTW & {
-	q: SnpsQ
-	term: SnpsTerm
-}
-
-type VariantFilter = {
-	active: any
-	filter: any
-	opts: any
-	terms: any
-}
-
-export type SnpsVocabApi = VocabApi & {
-	validateSnps: (f?: any) => {
-		error?: any
-		cacheid: string
-		snps: any
-		reachedVariantLimit: any
-	}
-	get_variantFilter: () => any
-}
-
-type SnpsDom = InstanceDom & {
-	input_AFcutoff_label: any
-	restrictAncestriesRow: any
-	setEffectAlleleAsHint: any
-	snplst_table: any
-}
-
-export type SnpsTermSettingInstance = TermSettingInstance & {
-	dom: SnpsDom
-	q: Partial<SnpsQ>
-	term: SnpsTerm
-	usecase: UseCase
-	variantFilter: VariantFilter
-	vocabApi: SnpsVocabApi
-}

package/src/terms/term.ts

@@ -1,184 +0,0 @@
-import { Filter } from '../filter.js'
-import { CategoricalTerm, CategoricalBaseQ } from './categorical.js'
-import { ConditionTerm } from './condition.js'
-import { NumericTerm } from './numeric.js'
-import { GeneVariantTerm } from './geneVariant.js'
-import { SampleLstTerm } from './samplelst.js'
-import { SnpsTerm } from './snps.js'
-
-/**
- * @param id      term.id for dictionary terms, undefined for non-dictionary terms
- * @params $id    client-computed deterministic unique identifier, to distinguish tw with the same term but different q, that are in the same payload
- */
-
-/*** types supporting termwrapper q ***/
-
-export type HiddenValues = {
-	[index: string]: number
-}
-
-// TODO: replace BaseQ with MinBaseQ (see below)
-// keeping BaseQ for now to not break old code
-export type BaseQ = {
-	/**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?: boolean
-	name?: string
-	mode?:
-		| 'discrete'
-		/** Binary is a special case of discrete. */
-		| 'binary'
-		| 'continuous'
-		/** Only for numeric terms in regression analysis. Requires q.knots */
-		| 'spline'
-		/** Only applies to condition term. Requires q.breaks[] to have one grade value.*/
-		| 'cuminc'
-		/** Only applies to condition term for cox regression outcome. Requires q.breaks[] to have one grade value, for event and q.timeScale.*/
-		| 'cox'
-
-	reuseId?: string
-	/** To define ways to divide up cohort based on a term, using methods specific to term types.*/
-	type?: /** Requires term.values{} to access categories for categorical term, and grade for condition term */
-	| 'values'
-		/** Applies to numeric terms */
-		| 'regular-bin'
-		/** Applies to numeric terms */
-		| 'custom-bin'
-		/** Applies to categorical, condition, geneVariant, and singleCellCellType terms */
-		| 'predefined-groupset'
-		/** Applies to categorical, condition, geneVariant, and singleCellCellType terms */
-		| 'custom-groupset'
-		/** Applies to samplelst terms */
-		| 'custom-samplelst'
-}
-
-export type ValuesQ = CategoricalBaseQ & {
-	type: 'values'
-}
-
-export type PredefinedGroupSettingQ = CategoricalBaseQ & {
-	type: 'predefined-groupset'
-	predefined_groupset_idx: number
-}
-
-export type CustomGroupSettingQ = CategoricalBaseQ & {
-	type: 'custom-groupset'
-	customset: BaseGroupSet
-}
-
-export type GroupSettingQ = ValuesQ | PredefinedGroupSettingQ | CustomGroupSettingQ
-
-/*** types supporting termwrapper term ***/
-
-export type BaseValue = {
-	key?: string
-	uncomputable?: boolean
-	label?: string | number
-	order?: string
-	color?: string
-	group?: number
-	filter?: Filter
-}
-
-export type TermValues = {
-	[key: string | number]: BaseValue
-}
-
-export type BaseTerm = {
-	id: string
-	name: string
-	type: string
-	child_types?: string[]
-	hashtmldetail?: boolean
-	included_types?: string[]
-	isleaf?: boolean
-	values?: TermValues
-}
-
-export type Term = BaseTerm &
-	(NumericTerm | CategoricalTerm | ConditionTerm | GeneVariantTerm | SampleLstTerm | SnpsTerm)
-
-export type ValuesGroup = {
-	name: string
-	type: 'values' | string // can remove boolean fallback once problematic js files are converted to .ts and can declare `type: 'values' as const`
-	values: { key: number | string; label: string }[]
-	uncomputable?: boolean // if true, do not include this group in computations
-}
-
-// TODO: determine if this is used
-export type FilterGroup = {
-	name: string
-	type: 'filter'
-	filter: Filter
-}
-
-export type GroupEntry = ValuesGroup | FilterGroup
-
-export type BaseGroupSet = {
-	groups: GroupEntry[]
-}
-
-type Groupset = {
-	name: string
-	is_grade?: boolean
-	is_subcondition?: boolean
-} & BaseGroupSet
-
-export type EnabledTermGroupSetting = {
-	disabled?: false | boolean // can remove boolean fallback once common.js is converted to .ts and can declare `disabled: false as const`
-	lst: Groupset[]
-}
-
-export type TermGroupSetting =
-	| EnabledTermGroupSetting
-	| {
-			/** disabled=false when groupsetting is not applicable for term (e.g., when term has only two categories) */
-			disabled: true | boolean // can remove boolean fallback once common.js is converted to .ts and can declare `disabled: true as const`
-			lst?: []
-	  }
-
-/*** types supporting termwrapper ***/
-
-export type BaseTW = {
-	id?: string
-	$id?: string
-	isAtomic?: true
-	// plot-specific customizations that are applied to a tw copy
-	// todo: should rethink these
-	legend?: any
-	settings?: {
-		[key: string]: any
-	}
-	sortSamples?: any
-	minNumSamples?: number
-	valueFilter?: any
-}
-
-/*** types supporting Term types ***/
-
-export type Subconditions = {
-	[index: string | number]: {
-		label: string
-	}
-}
-
-/*** other types ***/
-
-export type RangeEntry = {
-	//Used binconfig.lst[] and in tvs.ranges[]
-	start?: number
-	startunbounded?: boolean
-	startinclusive?: boolean
-	stop?: number
-	stopunbounded?: boolean
-	stopinclusive?: boolean
-	label?: string //for binconfig.lst[]
-	value?: string //for tvs.ranges[]
-	range?: any //No idea what this is
-}