Function defaultTableGenerator

src/lib/table-generator.ts:191–286

(tableOptions: Pick<TableOptions, 'groupRows'>)

}

export const defaultTableGenerator = (tableOptions: Pick<TableOptions, 'groupRows'>): TableGenerator => {
	const logger = log4js.getLogger('table-manager')

	const convertToLabel = (propertyName: string): string => {
		// We only use the last field for the name if it's a nested property.
		const propertyNames = propertyName.split('.')
		return propertyNames[propertyNames.length - 1]
			.replace(/([a-z])([A-Z])/g, '$1 $2')
			.replace(/^([a-z])/, text => text.toUpperCase())
			.replace(/\bUri\b/, 'URI')
			.replace(/\bUrl\b/, 'URL')
			.replace(/\bArn\b/, 'ARN')
			.replace(/\bO ?[Aa]uth\b/, 'OAuth')
			.replace(/^Is /, '')
	}

	const getLabelFor = <T extends object>(definition: TableFieldDefinition<T>): string => {
		if (typeof definition !== 'object') {
			return convertToLabel(definition.toString())
		}

		if (definition.label) {
			return definition.label
		}

		if ('value' in definition) {
			return definition.label
		}

		if ('prop' in definition) {
			return convertToLabel(definition.prop.toString())
		}

		return convertToLabel(definition.path)
	}

	const getDisplayValueFor = <T extends object>(item: T, definition: TableFieldDefinition<T>): string | undefined => {
		if (typeof definition === 'object' && 'value' in definition) {
			return definition.value(item)
		}

		if (typeof definition !== 'object' || 'prop' in definition) {
			const propertyName = typeof definition !== 'object' ? definition : definition.prop
			return stringFromUnknown(item[propertyName])
		}

		// The DefinitelyTyped type for the second parameter doesn't match what lodash actually
		// takes so we cast it to the DefinitelyTyped type.
		const matches = at(item, definition.path as unknown as keyof T)
		if (matches.length === 0) {
			logger.debug(`did not find match for ${definition.path} in ${JSON.stringify(item)}`)
			return ''
		}
		if (matches.length > 1) {
			logger.warn(`found more than one match for ${definition.path} in ${JSON.stringify(item)}`)
		}
		return matches.map(value => stringFromUnknown(value)).join(', ')
	}