chore: unify Array<T> -> T[]

src/__tests__/legacyAPI.ts

@@ -19,7 +19,7 @@ export interface TimelineObject {
 
 		[key: string]: any
 	}
-	classes?: Array<string>
+	classes?: string[]
 	disabled?: boolean
 	isGroup?: boolean
 	repeating?: boolean
@@ -56,7 +56,7 @@ export interface TimelineKeyframe {
 		// templateData?: any,
 		[key: string]: any
 	}
-	classes?: Array<string>
+	classes?: string[]
 }
 export interface UnresolvedLogicObject {
 	prevOnTimeline?: string | boolean | null
@@ -137,7 +137,7 @@ export interface Filter {
 	startTime?: StartTime
 	endTime?: EndTime
 }
-export type WhosAskingTrace = Array<string>
+export type WhosAskingTrace = string[]
 export type objAttributeFunction = (
 	objId: string,
 	hook: 'start' | 'end' | 'duration' | 'parentStart',

src/__tests__/timelineGenerator.ts

@@ -6,7 +6,7 @@ export function generateTimeline(seed: number, maxCount: number, maxGroupDepth:
 
 	const timeline: TimelineObject[] = []
 
-	const ref: Array<Array<TimelineObject>> = [timeline]
+	const ref: TimelineObject[][] = [timeline]
 
 	const layers: string[] = []
 	const layerCount = Math.ceil(random.get() * maxCount * 0.3)

src/api/expression.ts

@@ -17,6 +17,6 @@ export interface ExpressionObj {
 	r: Expression
 }
 export interface InnerExpression {
-	inner: Array<any> // string or Array<string>
-	rest: Array<string>
+	inner: any[]
+	rest: string[]
 }

src/api/resolvedTimeline.ts

@@ -18,12 +18,12 @@ export interface ResolvedTimeline<TContent extends Content = Content> {
 	/** Map of all objects on timeline */
 	objects: ResolvedTimelineObjects<TContent>
 	/** Map of all classes on timeline, maps className to object ids */
-	classes: { [className: string]: Array<string> }
+	classes: { [className: string]: string[] }
 	/** Map of the object ids, per layer */
-	layers: { [layer: string]: Array<string> }
+	layers: { [layer: string]: string[] }
 
 	// states: AllStates
-	nextEvents: Array<NextEvent>
+	nextEvents: NextEvent[]
 
 	statistics: {
 		/** Number of timeline objects (including keyframes) in the timeline */
@@ -56,7 +56,7 @@ export interface ResolvedTimelineObjects<TContent extends Content = Content> {
 export interface ResolvedTimelineObject<TContent extends Content = Content> extends TimelineObject<TContent> {
 	resolved: {
 		/** Instances of the object on the timeline */
-		instances: Array<TimelineObjectInstance>
+		instances: TimelineObjectInstance[]
 		/** A number that increases the more levels inside of a group the objects is. 0 = no parent */
 		levelDeep: number
 		/** Id of the parent object (for children in groups or keyframes) */
@@ -103,10 +103,10 @@ export interface TimelineObjectInstance extends InstanceBase {
 	originalEnd?: Time | null
 
 	/** array of the id of the referenced objects */
-	references: Array<Reference>
+	references: Reference[]
 
 	/** If set, tells the cap of the parent. The instance will always be capped inside this. */
-	caps?: Array<Cap>
+	caps?: Cap[]
 	/** If the instance was generated from another instance, reference to the original */
 	fromInstanceId?: string
 }

src/api/timeline.ts

@@ -31,7 +31,7 @@ export interface TimelineObject<TContent extends Content = Content> {
 	/**
 	 * A list of classes on this Timeline-object. classes can be referenced by other objects using the syntax: ".className"
 	 */
-	classes?: Array<string>
+	classes?: string[]
 
 	/** If set to true, the object will be excluded when resolving the timeline. */
 	disabled?: boolean
@@ -95,7 +95,7 @@ export interface TimelineKeyframe<TContent extends Content = Content> {
 	/**
 	 * A list of classes on this Timeline-object. classes can be referenced by other objects using the syntax: ".className"
 	 */
-	classes?: Array<string>
+	classes?: string[]
 
 	/** If set to true, the object will be excluded when resolving the timeline. */
 	disabled?: boolean

src/index.ts

@@ -110,7 +110,7 @@ export function simplifyExpression(expr0: Expression): Expression {
 export function wrapInnerExpressions(words: Array<any>): InnerExpression {
 	return getExpressionHandler().wrapInnerExpressions(words)
 }
-export function validateExpression(operatorList: Array<string>, expr0: Expression, breadcrumbs?: string): true {
+export function validateExpression(operatorList: string[], expr0: Expression, breadcrumbs?: string): true {
 	return getExpressionHandler().validateExpression(operatorList, expr0, breadcrumbs)
 }
 

src/resolver/ExpressionHandler.ts

@@ -28,7 +28,7 @@ export class ExpressionHandler {
 				() => {
 					const expr = expressionString.replace(REGEXP_OPERATORS, ' $1 ') // Make sure there's a space between every operator & operand
 
-					const words: Array<string> = compact(expr.split(' '))
+					const words: string[] = compact(expr.split(' '))
 
 					if (words.length === 0) return null // empty expression
 
@@ -98,7 +98,7 @@ export class ExpressionHandler {
 
 	// Turns ['a', '(', 'b', 'c', ')'] into ['a', ['b', 'c']]
 	// or ['a', '&', '!', 'b'] into ['a', '&', ['', '!', 'b']]
-	public wrapInnerExpressions(words: Array<any>): InnerExpression {
+	public wrapInnerExpressions(words: any[]): InnerExpression {
 		for (let i = 0; i < words.length; i++) {
 			if (words[i] === '(') {
 				const tmp = this.wrapInnerExpressions(words.slice(i + 1))
@@ -126,7 +126,7 @@ export class ExpressionHandler {
 	}
 
 	/** Validates an expression. Returns true on success, throws error if not */
-	public validateExpression(operatorList: Array<string>, expr0: Expression, breadcrumbs?: string): true {
+	public validateExpression(operatorList: string[], expr0: Expression, breadcrumbs?: string): true {
 		if (!breadcrumbs) breadcrumbs = 'ROOT'
 
 		if (isObject(expr0) && !isArray(expr0)) {
@@ -156,7 +156,7 @@ export class ExpressionHandler {
 	public clearCache(): void {
 		this.cache.clear()
 	}
-	private words2Expression(operatorList: Array<string>, words: Array<any>): Expression {
+	private words2Expression(operatorList: string[], words: any[]): Expression {
 		/* istanbul ignore if */
 		if (!words?.length) throw new Error('words2Expression: syntax error: unbalanced expression')
 		while (words.length === 1 && words[0] !== null && isArray(words[0])) words = words[0]

src/resolver/InstanceHandler.ts

@@ -11,10 +11,10 @@ import { joinReferences, isReference } from './lib/reference'
 export class InstanceHandler {
 	constructor(private resolvedTimeline: ResolvedTimelineHandler) {}
 
-	public invertInstances(instances: Array<TimelineObjectInstance>): Array<TimelineObjectInstance> {
+	public invertInstances(instances: TimelineObjectInstance[]): TimelineObjectInstance[] {
 		if (instances.length) {
 			instances = this.cleanInstances(instances, true, true)
-			const invertedInstances: Array<TimelineObjectInstance> = []
+			const invertedInstances: TimelineObjectInstance[] = []
 			if (instances[0].start !== 0) {
 				invertedInstances.push({
 					id: this.resolvedTimeline.getInstanceId(),
@@ -54,11 +54,11 @@ export class InstanceHandler {
 		}
 	}
 	public convertEventsToInstances(
-		events: Array<EventForInstance>,
+		events: EventForInstance[],
 		allowMerge: boolean,
 		allowZeroGaps = false,
 		omitOriginalStartEnd = false
-	): Array<TimelineObjectInstance> {
+	): TimelineObjectInstance[] {
 		sortEvents(events)
 
 		const activeInstances: { [eventId: string]: InstanceEvent } = {}
@@ -69,7 +69,7 @@ export class InstanceHandler {
 		let previousNegative = false
 		let negativeInstanceId: string | null = null
 
-		const returnInstances: Array<TimelineObjectInstance> = []
+		const returnInstances: TimelineObjectInstance[] = []
 		for (let i = 0; i < events.length; i++) {
 			const event = events[i]
 			const eventId: string = event.data.id ?? event.data.instance.id
@@ -272,15 +272,15 @@ export class InstanceHandler {
 	 * @param instances
 	 */
 	public cleanInstances(
-		instances: Array<TimelineObjectInstance>,
+		instances: TimelineObjectInstance[],
 		allowMerge: boolean,
 		allowZeroGaps = false
-	): Array<TimelineObjectInstance> {
+	): TimelineObjectInstance[] {
 		// First, optimize for certain common situations:
 		if (instances.length === 0) return []
 		if (instances.length === 1) return instances
 
-		const events: Array<EventForInstance> = []
+		const events: EventForInstance[] = []
 
 		for (let i = 0; i < instances.length; i++) {
 			const instance = instances[i]

src/resolver/LayerStateHandler.ts

@@ -71,7 +71,7 @@ export class LayerStateHandler {
 			// We also assume that the object has a layer
 
 			for (const instance of obj.resolved.instances) {
-				const timeEvents: Array<TimeEvent> = []
+				const timeEvents: TimeEvent[] = []
 
 				timeEvents.push({ time: instance.start, enable: true })
 				if (instance.end) timeEvents.push({ time: instance.end, enable: false })

src/resolver/ReferenceHandler.ts

@@ -13,7 +13,7 @@ import { isNumericExpr } from './lib/expression'
 type ObjectRefType = 'start' | 'end' | 'duration'
 export interface ValueWithReference {
 	value: number
-	references: Array<Reference>
+	references: Reference[]
 }
 type LookupResult = {
 	result: TimelineObjectInstance[] | ValueWithReference | null
@@ -26,7 +26,7 @@ export class ReferenceHandler {
 	/**
 	 * Look up a reference on the timeline
 	 * Return values:
-	 * Array<TimelineObjectInstance>: Instances on the timeline where the reference expression is true
+	 * TimelineObjectInstance[]: Instances on the timeline where the reference expression is true
 	 * ValueWithReference: A singular value which can be combined arithmetically with Instances
 	 * null: Means "something is invalid", an null-value will always return null when combined with other values
 	 *
@@ -198,7 +198,7 @@ export class ReferenceHandler {
 			return operate(array0, array1)
 		}
 
-		const result: Array<TimelineObjectInstance> = []
+		const result: TimelineObjectInstance[] = []
 
 		const minLength = Math.min(
 			isArray(array0) ? array0.length : Infinity,
@@ -265,7 +265,7 @@ export class ReferenceHandler {
 		referencedObjs: ResolvedTimelineObject[],
 		allReferences: Reference[]
 	): LookupResult {
-		const instanceDurations: Array<ValueWithReference> = []
+		const instanceDurations: ValueWithReference[] = []
 		for (let i = 0; i < referencedObjs.length; i++) {
 			const referencedObj: ResolvedTimelineObject = referencedObjs[i]
 
@@ -482,7 +482,7 @@ class ReferenceAndOrCombiner {
 
 			if (!next || next.time !== e.time) {
 				const newResultValue = this.calcResult(leftValue, rightValue)
-				const resultCaps: Array<Cap> = (leftInstance ? leftInstance.caps ?? [] : []).concat(
+				const resultCaps: Cap[] = (leftInstance ? leftInstance.caps ?? [] : []).concat(
 					rightInstance ? rightInstance.caps ?? [] : []
 				)
 
@@ -504,7 +504,7 @@ class ReferenceAndOrCombiner {
 		return this.instances
 	}
 
-	private updateInstance(time: Time, value: boolean, references: Reference[], caps: Array<Cap>) {
+	private updateInstance(time: Time, value: boolean, references: Reference[], caps: Cap[]) {
 		if (value) {
 			this.instances.push({
 				id: this.resolvedTimeline.getInstanceId(),

src/resolver/TimelineValidator.ts

@@ -27,7 +27,7 @@ export class TimelineValidator {
 	/** Validates all objects in the timeline. Throws an error if something's wrong. */
 	public validateTimeline(
 		/** The timeline to validate */
-		timeline: Array<TimelineObject>,
+		timeline: TimelineObject[],
 		/** Set to true to enable some optional strict rules. Set this to true to increase future compatibility. */
 		strict?: boolean
 	): void {

src/resolver/lib/cap.ts

@@ -1,6 +1,6 @@
 import { Cap, TimelineObjectInstance } from '../../api'
 
-export function joinCaps(...caps: Array<Array<Cap> | undefined>): Array<Cap> {
+export function joinCaps(...caps: Array<Cap[] | undefined>): Cap[] {
 	const capMap: { [capReference: string]: Cap } = {}
 	for (let i = 0; i < caps.length; i++) {
 		const caps2 = caps[i]
@@ -13,7 +13,7 @@ export function joinCaps(...caps: Array<Array<Cap> | undefined>): Array<Cap> {
 	}
 	return Object.values<Cap>(capMap)
 }
-export function addCapsToResuming(instance: TimelineObjectInstance, ...caps: Array<Array<Cap> | undefined>): void {
+export function addCapsToResuming(instance: TimelineObjectInstance, ...caps: Array<Cap[] | undefined>): void {
 	const capsToAdd: Cap[] = []
 	const joinedCaps = joinCaps(...caps)
 	for (let i = 0; i < joinedCaps.length; i++) {

src/resolver/lib/event.ts

@@ -13,9 +13,9 @@ export type EventForInstance = InstanceEvent<{
 }>
 
 export function sortEvents<T extends InstanceEvent>(
-	events: Array<T>,
+	events: T[],
 	additionalSortFcnBefore?: (a: T, b: T) => number
-): Array<T> {
+): T[] {
 	return events.sort((a: T, b: T) => {
 		if (a.time > b.time) return 1
 		if (a.time < b.time) return -1