implemented suggestions

Author: Saksham-Sirohi

src/pretalx/frontend/schedule-editor/eslint.config.js

@@ -1,14 +1,66 @@
 import vue from 'eslint-plugin-vue'
 import vuePug from 'eslint-plugin-vue-pug'
 import js from '@eslint/js'
+import tseslint from '@typescript-eslint/eslint-plugin'
+import tsParser from '@typescript-eslint/parser'
 
 export default [
   // Base JavaScript recommended rules
   js.configs.recommended,
 
+  // TypeScript recommended rules for .ts files
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: 2022,
+        sourceType: 'module',
+        project: './tsconfig.json'
+      }
+    },
+    plugins: {
+      '@typescript-eslint': tseslint
+    },
+    rules: {
+      ...tseslint.configs.recommended.rules,
+      // TypeScript-specific rules
+      '@typescript-eslint/no-unused-vars': 'warn',
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/explicit-module-boundary-types': 'off',
+      '@typescript-eslint/no-non-null-assertion': 'warn',
+      '@typescript-eslint/no-empty-object-type': 'warn'
+    }
+  },
+  
   // Vue 3 recommended configuration
   ...vue.configs['flat/recommended'],
 
+  // Vue + TypeScript configuration (separate from pure TS to avoid project issues)
+  {
+    files: ['**/*.vue'],
+    languageOptions: {
+      parser: vue.parser,
+      parserOptions: {
+        ecmaVersion: 2022,
+        sourceType: 'module',
+        parser: {
+          ts: tsParser
+        }
+        // Removed project reference for Vue files to avoid parsing issues
+      }
+    },
+    plugins: {
+      '@typescript-eslint': tseslint
+    },
+    rules: {
+      // Apply some TypeScript rules to Vue files as well
+      '@typescript-eslint/no-unused-vars': 'warn',
+      '@typescript-eslint/no-explicit-any': 'warn'
+    }
+  },
+  
   // Vue Pug configuration
   {
     plugins: {
@@ -20,6 +72,7 @@ export default [
   },
 
   {
+    files: ['**/*.js', '**/*.ts', '**/*.vue'],
     languageOptions: {
       ecmaVersion: 2022,
       sourceType: 'module',
@@ -37,13 +90,16 @@ export default [
       // Formatting and style rules
       'arrow-parens': 'off',
       'generator-star-spacing': 'off',
-      'indent': ['error', 'tab', { SwitchCase: 1 }],
-      'no-tabs': 'off',
+      'indent': 'off', // Disable indentation rule due to mixed codebase
+      'no-tabs': 'off', // Allow both tabs and spaces
       'comma-dangle': 'off',
       'curly': 'off',
       'no-return-assign': 'off',
       'object-curly-spacing': 'off',
 
+      // Override JS no-unused-vars for TypeScript files (handled by @typescript-eslint/no-unused-vars)
+      'no-unused-vars': 'off',
+      
       // Vue-specific rules
       'vue/require-default-prop': 'off',
       'vue/multi-word-component-names': 'off',
@@ -57,9 +113,6 @@ export default [
       'vue/no-undef-properties': 'off',
       'vue/require-explicit-emits': 'off',
       'vue/no-mutating-props': 'error',
-      
-      // JavaScript rules
-      'no-unused-vars': 'warn',
     }
   }
 ]

src/pretalx/frontend/schedule-editor/src/api.ts

@@ -1,97 +1,27 @@
-import { z } from 'zod';
+import { 
+  ScheduleSchema, 
+  AvailabilitySchema, 
+  WarningsSchema, 
+  TalkSchema,
+  Talk,
+  Schedule,
+  Availability,
+  Warnings
+} from './schemas';
 
 const basePath = process.env.BASE_PATH || '/talk';
 
-const SpeakerSchema = z.object({
-  code: z.string(),
-  name: z.string(),
-});
-
-// Title can be a string or a language object like {en: "Title"}
-const toTitleRecord = (val: unknown): Record<string, string> => {
-  if (val !== null && typeof val === 'object') {
-    return val as Record<string, string>;
-  }
-  if (typeof val === 'string') {
-    return { en: val };
+const calculateDuration = (start?: string, end?: string): number | undefined => {
+  if (!start || !end) return undefined;
+  try {
+    const startTime = new Date(start).getTime();
+    const endTime = new Date(end).getTime();
+    return (endTime - startTime) / (1000 * 60);
+  } catch {
+    return undefined;
   }
-  return { en: '' };
 };
 
-// Room schema
-const RoomSchema = z.object({
-  id: z.number(),
-  name: z.record(z.string(), z.string()).default({}),
-  description: z.record(z.string(), z.string()).default({})
-});
-
-const TrackSchema = z.object({
-  id: z.number(),
-  name: z.record(z.string(), z.string()).default({})
-});
-
-// Talk schema
-const TalkSchema = z.object({
-  id: z.number(),
-  // Some talks have code, some don't
-  code: z.string().optional(),
-  title: z.union([
-    z.string(),
-    z.record(z.string(), z.string())
-  ]).transform(toTitleRecord),
-  abstract: z.string().optional(),
-  speakers: z.array(z.string()).optional().default([]),
-  // Room and track come as numbers in the API
-  room: z.union([
-    z.number(),
-    z.string().transform(val => parseInt(val, 10) || null)
-  ]).nullable().optional(),
-  track: z.union([
-    z.number(),
-    z.string().transform(val => parseInt(val, 10) || null)
-  ]).nullable().optional(),
-
-  start: z.string().nullable().optional(),
-  end: z.string().nullable().optional(),
-  state: z.string().optional(),
-  updated: z.string().optional(),
-  uncreated: z.boolean().optional(),
-  availabilities: z.array(z.unknown()).optional().default([]),
-  // Duration field - it appears some talks don't have this field
-  duration: z.number().optional()
-});
-
-// Main schedule schema
-const ScheduleSchema = z.object({
-  version: z.nullable(z.string().nullable()),
-  event_start: z.string(),
-  event_end: z.string(),
-  timezone: z.string(),
-  locales: z.array(z.string()).default([]),
-  rooms: z.array(RoomSchema).default([]),
-  tracks: z.array(TrackSchema).default([]),
-  speakers: z.array(SpeakerSchema).default([]),
-  talks: z.array(TalkSchema).default([]),
-  now: z.string().optional(),
-  warnings: z.record(z.string(), z.any()).optional().default({})
-});
-
-const AvailabilitySchema = z.object({
-  rooms: z.record(z.string(), z.array(z.object({ 
-    start: z.string(), 
-    end: z.string() 
-  }))).optional(),
-  talks: z.record(z.string(), z.array(z.object({ 
-    start: z.string(), 
-    end: z.string() 
-  }))).optional(),
-});
-
-const WarningSchema = z.object({
-  message: z.string(),
-});
-
-const WarningsSchema = z.record(z.string(), z.array(WarningSchema)).optional();
 interface TalkPayload {
   id?: number;
   code?: string;
@@ -103,30 +33,15 @@ interface TalkPayload {
   duration?: number;
 }
 
-// Helper to calculate duration in minutes from start and end time strings
-const calculateDuration = (start?: string, end?: string): number | undefined => {
-  if (!start || !end) return undefined;
-  
-  try {
-    const startTime = new Date(start).getTime();
-    const endTime = new Date(end).getTime();
-    return (endTime - startTime) / (1000 * 60); // Duration in minutes
-  } catch (e) {
-    return undefined;
-  }
-};
-
 const api = {
   eventSlug: basePath ? window.location.pathname.split("/")[4] : window.location.pathname.split("/")[3],
 
   async http<T>(verb: string, url: string, body: unknown): Promise<T> {
     const headers: Record<string, string> = {};
-    if (body) {
-      headers['Content-Type'] = 'application/json';
-    }
+    if (body) headers['Content-Type'] = 'application/json';
 
     const options: RequestInit = {
-      method: verb || 'GET',
+      method: verb,
       headers,
       body: body ? JSON.stringify(body) : undefined,
       credentials: 'include',
@@ -147,68 +62,54 @@ const api = {
     return json as T;
   },
 
-  async fetchTalks(options?: { since?: string; warnings?: boolean }): Promise<z.infer<typeof ScheduleSchema>> {
+  async fetchTalks(options?: { since?: string; warnings?: boolean }): Promise<Schedule> {
     let url = `${basePath}/orga/event/${this.eventSlug}/schedule/api/talks/`;
-    
-    // Build query parameters
-    const params = new URLSearchParams();
-    if (window.location.search) {
-      new URLSearchParams(window.location.search).forEach((value, key) => {
-        params.append(key, value);
-      });
-    }
+    const params = new URLSearchParams(window.location.search);
     if (options?.since) params.append('since', options.since);
     if (options?.warnings) params.append('warnings', 'true');
-    
     url += `?${params.toString()}`;
 
-    const data = await this.http('GET', url, null);
+    const data = await this.http<unknown>('GET', url, null);
     return ScheduleSchema.parse(data);
   },
 
-  async fetchAvailabilities(): Promise<z.infer<typeof AvailabilitySchema>> {
+  async fetchAvailabilities(): Promise<Availability> {
     const url = `${basePath}/orga/event/${this.eventSlug}/schedule/api/availabilities/`;
-    const data = await this.http('GET', url, null);
+    const data = await this.http<unknown>('GET', url, null);
     return AvailabilitySchema.parse(data);
   },
 
-  async fetchWarnings(): Promise<z.infer<typeof WarningsSchema>> {
+  async fetchWarnings(): Promise<Warnings> {
     const url = `${basePath}/orga/event/${this.eventSlug}/schedule/api/warnings/`;
-    const data = await this.http('GET', url, null);
+    const data = await this.http<unknown>('GET', url, null);
     return WarningsSchema.parse(data);
   },
 
   async saveTalk(
     talk: TalkPayload,
     { action = 'PATCH' }: { action?: string } = {}
-  ): Promise<z.infer<typeof TalkSchema> | void> {
+  ): Promise<Talk | void> {
     const url = new URL(window.location.href);
     url.pathname = `${url.pathname}api/talks/${talk.id ? `${talk.id}/` : ''}`;
     url.search = window.location.search;
 
     let payload: unknown = undefined;
     if (action !== 'DELETE') {
-      const roomId = talk.room && typeof talk.room === 'object' 
-        ? talk.room.id 
-        : talk.room;
-        
-      // Calculate duration if not provided but we have start and end times
+      const roomId = typeof talk.room === 'object' ? talk.room.id : talk.room;
       const duration = talk.duration ?? calculateDuration(talk.start, talk.end);
 
       payload = {
         room: roomId,
         start: talk.start,
         end: talk.end,
-        duration: duration,
+        duration,
         title: talk.title,
         description: talk.description,
       };
     }
 
-    // Make request
     const response = await this.http<unknown>(action, url.toString(), payload);
 
-    // Validate and return response
     if (action !== 'DELETE') {
       return TalkSchema.parse(response);
     }
@@ -218,10 +119,13 @@ const api = {
     await this.saveTalk({ id: talk.id }, { action: 'DELETE' });
   },
 
-  async createTalk(talk: Omit<TalkPayload, 'id'>): Promise<z.infer<typeof TalkSchema>> {
-    const response = await this.saveTalk(talk, { action: 'POST' }) as z.infer<typeof TalkSchema>;
-    return TalkSchema.parse(response);
+  async createTalk(talk: Omit<TalkPayload, 'id'>): Promise<Talk> {
+    const response = await this.saveTalk(talk, { action: 'POST' });
+    if (!response) {
+      throw new Error('Failed to create talk: No response from server');
+    }
+    return response;
   }
 };
 
-export default api
+export default api