Bump to TypeScript 5.7 with strictFunctionTypes

This commit migrates from TypeScript 5.6 to 5.7 with
`strictFunctionTypes` flag enabled for stricter quality controls.

Other changes:

- Create type helpers for `Object.keys` and `Object.entries` to
  explicitly document their usage and intent.
- Update `vue-tsc` to latest to prevent build errors with TypeScript
  5.7.x.

Author: undergroundwires

package-lock.json

@@ -79,7 +79,7 @@
     "start-server-and-test": "^2.0.10",
     "terser": "^5.39.0",
     "tslib": "^2.8.1",
-    "typescript": "~5.6.3",
+    "typescript": "~5.7.3",
     "vite": "^6.2.0",
     "vite-plugin-minify": "^2.1.0",
     "vitest": "^3.0.7",

package.json

@@ -1,18 +1,19 @@
 export type Constructible<T, TArgs extends unknown[] = never> = {
   prototype: T;
-  apply: (this: unknown, args: TArgs) => void;
+  apply: (this: () => unknown, args: TArgs) => void;
   readonly name: string;
 };
 
 export type PropertyKeys<T> = {
-  [K in keyof T]: T[K] extends (...args: unknown[]) => unknown ? never : K;
+  [K in keyof T]: T[K] extends (...args: never[]) => unknown ? never : K
 }[keyof T];
 
+
 export type ConstructorArguments<T> =
   T extends new (...args: infer U) => unknown ? U : never;
 
 export type FunctionKeys<T> = {
-  [K in keyof T]: T[K] extends (...args: unknown[]) => unknown ? K : never;
+  [K in keyof T]: T[K] extends (...args: never[]) => unknown ? K : never;
 }[keyof T];
 
 export function isString(value: unknown): value is string {
@@ -46,3 +47,30 @@ export function isPlainObject(
 export function isNullOrUndefined(value: unknown): value is (null | undefined) {
   return typeof value === 'undefined' || value === null;
 }
+
+/**
+ * Gets keys of object T, assuming all properties match the type.
+ * Warning: May include properties not defined in T's type.
+ * Details: https://stackoverflow.com/questions/55012174/why-doesnt-object-keys-return-a-keyof-type-in-typescript
+ */
+export function getUnsafeTypedKeys<T extends object>(obj: T): (keyof T)[] {
+  return downcast(Object.keys(obj));
+}
+
+/**
+ * Gets entries of object T, assuming all properties match the type.
+ * Warning: May include properties not defined in T's type.
+ * Details: https://stackoverflow.com/questions/60141960/typescript-key-value-relation-preserving-object-entries-type
+ */
+export function getUnsafeTypedEntries<T extends object>(
+  obj: T,
+): TypedEntries<T> {
+  return downcast(Object.entries(obj));
+}
+type TypedEntries<T> = readonly ({
+  [K in keyof T]: [K, T[K]];
+}[keyof T])[];
+
+function downcast<T = object>(obj: object): T {
+  return obj as T;
+}

src/TypeHelpers.ts

@@ -2,7 +2,9 @@
 import { PlatformTimer } from './PlatformTimer';
 import type { Timer, TimeoutType } from './Timer';
 
-export type CallbackType = (..._: readonly unknown[]) => void;
+export type CallbackType<TCallbackArgs extends unknown[]> = (
+  ..._: TCallbackArgs
+) => void;
 
 export interface ThrottleOptions {
   /** Skip the immediate execution of the callback on the first invoke */
@@ -16,42 +18,42 @@ const DefaultOptions: ThrottleOptions = {
 };
 
 export interface ThrottleFunction {
-  (
-    callback: CallbackType,
+  <TCallbackArgs extends unknown[]>(
+    callback: CallbackType<TCallbackArgs>,
     waitInMs: number,
     options?: Partial<ThrottleOptions>,
-  ): CallbackType;
+  ): CallbackType<TCallbackArgs>;
 }
 
-export const throttle: ThrottleFunction = (
-  callback: CallbackType,
+export const throttle: ThrottleFunction = <TCallbackArgs extends unknown[]>(
+  callback: CallbackType<TCallbackArgs>,
   waitInMs: number,
   options: Partial<ThrottleOptions> = DefaultOptions,
-): CallbackType => {
+): CallbackType<TCallbackArgs> => {
   const defaultedOptions: ThrottleOptions = {
     ...DefaultOptions,
     ...options,
   };
   const throttler = new Throttler(waitInMs, callback, defaultedOptions);
-  return (...args: unknown[]) => throttler.invoke(...args);
+  return (...args: TCallbackArgs) => throttler.invoke(...args);
 };
 
-class Throttler {
+class Throttler<TCallbackArgs extends unknown[]> {
   private lastExecutionTime: number | null = null;
 
   private executionScheduler: DelayedCallbackScheduler;
 
   constructor(
     private readonly waitInMs: number,
-    private readonly callback: CallbackType,
+    private readonly callback: CallbackType<TCallbackArgs>,
     private readonly options: ThrottleOptions,
   ) {
     if (!waitInMs) { throw new Error('missing delay'); }
     if (waitInMs < 0) { throw new Error('negative delay'); }
     this.executionScheduler = new DelayedCallbackScheduler(options.timer);
   }
 
-  public invoke(...args: unknown[]): void {
+  public invoke(...args: TCallbackArgs): void {
     switch (true) {
       case this.isLeadingCallWithinThrottlePeriod(): {
         if (this.options.excludeLeadingCall) {
@@ -92,7 +94,7 @@ class Throttler {
     return this.executionScheduler.getNext() !== null;
   }
 
-  private scheduleNext(args: unknown[]): void {
+  private scheduleNext(args: TCallbackArgs): void {
     if (this.executionScheduler.getNext()) {
       throw new Error('An execution is already scheduled.');
     }
@@ -102,7 +104,7 @@ class Throttler {
     );
   }
 
-  private updateNextScheduled(args: unknown[]): void {
+  private updateNextScheduled(args: TCallbackArgs): void {
     const nextScheduled = this.executionScheduler.getNext();
     if (!nextScheduled) {
       throw new Error('A non-existent scheduled execution cannot be updated.');
@@ -114,7 +116,7 @@ class Throttler {
     );
   }
 
-  private executeNow(args: unknown[]): void {
+  private executeNow(args: TCallbackArgs): void {
     this.callback(...args);
     this.lastExecutionTime = this.dateNow();
   }

src/application/Common/Timing/Throttle.ts

@@ -94,9 +94,9 @@ function assertAllowedProperties(
   valueName: string,
   allowedProperties: readonly string[],
 ): void {
-  const properties = Object.keys(value).map((p) => p as string);
-  const disallowedProperties = properties.filter(
-    (prop) => !allowedProperties.map((p) => p as string).includes(prop),
+  const allProperties = Object.keys(value);
+  const disallowedProperties = allProperties.filter(
+    (prop) => !allowedProperties.includes(prop),
   );
   if (disallowedProperties.length > 0) {
     throw new Error(`'${valueName}' has disallowed properties: ${disallowedProperties.join(', ')}.`);

src/application/Common/TypeValidator.ts

@@ -2,7 +2,7 @@ import { ContextIsolatedElectronDetector } from '@/infrastructure/RuntimeEnviron
 import type { ElectronEnvironmentDetector } from '@/infrastructure/RuntimeEnvironment/Electron/ElectronEnvironmentDetector';
 import { OperatingSystem } from '@/domain/OperatingSystem';
 import {
-  type PropertyKeys, isBoolean, isFunction, isNumber, isPlainObject,
+  type PropertyKeys, getUnsafeTypedEntries, isBoolean, isFunction, isNumber, isPlainObject,
 } from '@/TypeHelpers';
 import type { WindowVariables } from './WindowVariables';
 
@@ -36,9 +36,9 @@ function* testEveryProperty(variables: Partial<WindowVariables>): Iterable<strin
     scriptDiagnosticsCollector: testScriptDiagnosticsCollector(variables),
   };
 
-  for (const [propertyName, testResult] of Object.entries(tests)) {
+  for (const [propertyName, testResult] of getUnsafeTypedEntries(tests)) {
     if (!testResult) {
-      const propertyValue = variables[propertyName as keyof WindowVariables];
+      const propertyValue = variables[propertyName];
       yield `Unexpected ${propertyName} (${typeof propertyValue})`;
     }
   }

src/infrastructure/WindowVariables/WindowVariablesValidator.ts

@@ -2,8 +2,8 @@ import {
   onUnmounted, ref, shallowReadonly, watch,
 } from 'vue';
 import { throttle } from '@/application/Common/Timing/Throttle';
+import type { LifecycleHook } from '@/presentation/components/Shared/Hooks/Common/LifecycleHook';
 import type { Ref } from 'vue';
-import type { LifecycleHook } from '../../Shared/Hooks/Common/LifecycleHook';
 
 const ThrottleInMs = 15;
 
@@ -18,7 +18,7 @@ export function useDragHandler(
 
   let initialPointerX: number | undefined;
 
-  const onDrag = throttler((event: PointerEvent) => {
+  const onDrag = throttler((event: PointerEvent): void => {
     if (initialPointerX === undefined) {
       throw new Error('Resize action started without an initial X coordinate.');
     }
@@ -64,28 +64,34 @@ export function useDragHandler(
   };
 }
 
+export type DocumentEventKey = keyof DocumentEventMap;
+
+export type DocumentEventHandler<TEvent extends DocumentEventKey> = (
+  event: DocumentEventMap[TEvent],
+) => void;
+
 export interface DragDomModifier {
-  addEventListenerToDocument(
-    type: keyof DocumentEventMap,
-    handler: EventListener,
+  addEventListenerToDocument<TEvent extends DocumentEventKey>(
+    type: TEvent,
+    handler: DocumentEventHandler<TEvent>
   ): void;
-  removeEventListenerFromDocument(
-    type: keyof DocumentEventMap,
-    handler: EventListener,
+  removeEventListenerFromDocument<TEvent extends DocumentEventKey>(
+    type: TEvent,
+    handler: DocumentEventHandler<TEvent>,
   ): void;
 }
 
 class GlobalDocumentDragDomModifier implements DragDomModifier {
-  public addEventListenerToDocument(
-    type: keyof DocumentEventMap,
-    listener: EventListener,
+  public addEventListenerToDocument<TEvent extends DocumentEventKey>(
+    type: TEvent,
+    listener: DocumentEventHandler<TEvent>,
   ): void {
     document.addEventListener(type, listener);
   }
 
-  public removeEventListenerFromDocument(
-    type: keyof DocumentEventMap,
-    listener: EventListener,
+  public removeEventListenerFromDocument<TEvent extends DocumentEventKey>(
+    type: TEvent,
+    listener: DocumentEventHandler<TEvent>,
   ): void {
     document.removeEventListener(type, listener);
   }

src/presentation/components/Scripts/Slider/UseDragHandler.ts

@@ -1,7 +1,6 @@
 import {
   type Ref, shallowReadonly, shallowRef,
 } from 'vue';
-import type { Category } from '@/domain/Executables/Category/Category';
 import { injectKey } from '@/presentation/injectionSymbols';
 import type { ReadonlyFilterContext } from '@/application/Context/State/Filter/FilterContext';
 import type { FilterResult } from '@/application/Context/State/Filter/Result/FilterResult';
@@ -81,6 +80,6 @@ function containsExecutable(
   executables: readonly Executable[],
 ): boolean {
   return executables.some(
-    (existing: Category) => existing.executableId === expectedId,
+    (existing) => existing.executableId === expectedId,
   );
 }

src/presentation/components/Scripts/View/Tree/TreeViewAdapter/UseTreeViewFilterEvent.ts

@@ -1,5 +1,6 @@
 import { PlatformTimer } from '@/application/Common/Timing/PlatformTimer';
 import type { Timer } from '@/application/Common/Timing/Timer';
+import { getUnsafeTypedEntries } from '@/TypeHelpers';
 
 export type AnimationFunction = (element: Element) => Promise<void>;
 
@@ -98,8 +99,8 @@ function setTransitionPropertiesToElementDimensions(
   elementStyle: ElementStyleMutator,
   elementDimensions: TransitionStyleRecords,
 ): void {
-  Object.entries(elementDimensions).forEach(([key, value]) => {
-    elementStyle.changeStyle(key as AnimatedStyleProperty, value);
+  getUnsafeTypedEntries(elementDimensions).forEach(([key, value]) => {
+    elementStyle.changeStyle(key, value);
   });
 }
 
@@ -175,8 +176,8 @@ function restoreOriginalStyles(
   element: HTMLElement,
   originalStyles: MutatedStyleProperties,
 ): void {
-  Object.entries(originalStyles).forEach(([key, value]) => {
-    element.style[key as MutatedStyleProperty] = value;
+  getUnsafeTypedEntries(originalStyles).forEach(([key, value]) => {
+    element.style[key] = value;
   });
 }
 

src/presentation/components/Shared/ExpandCollapse/UseExpandCollapseAnimation.ts

@@ -40,14 +40,14 @@ export interface TargetEventListener {
   startListening<TEvent extends keyof HTMLElementEventMap>(
     eventTargetSource: EventTargetOrRef,
     eventType: TEvent,
-    eventHandler: (event: HTMLElementEventMap[TEvent]) => void,
+    eventHandler: TypedEventHandler<TEvent>,
   ): void;
 }
 
 function startListeningRef<TEvent extends keyof HTMLElementEventMap>(
   eventTargetRef: Readonly<Ref<EventTarget | undefined>>,
   eventType: TEvent,
-  eventHandler: (event: HTMLElementEventMap[TEvent]) => void,
+  eventHandler: TypedEventHandler<TEvent>,
   onTeardown: LifecycleHook,
 ): void {
   const eventListenerManager = new EventListenerManager();
@@ -78,9 +78,14 @@ class EventListenerManager {
   public addListener<TEvent extends keyof HTMLElementEventMap>(
     eventTarget: EventTarget,
     eventType: TEvent,
-    eventHandler: (event: HTMLElementEventMap[TEvent]) => void,
+    eventHandler: TypedEventHandler<TEvent>,
   ) {
-    eventTarget.addEventListener(eventType, eventHandler);
-    this.removeListener = () => eventTarget.removeEventListener(eventType, eventHandler);
+    const listener = eventHandler as EventListener;
+    eventTarget.addEventListener(eventType, listener);
+    this.removeListener = () => eventTarget.removeEventListener(eventType, listener);
   }
 }
+
+type TypedEventHandler<
+  TEvent extends (keyof HTMLElementEventMap),
+> = ((event: HTMLElementEventMap[TEvent]) => void);