@thinkwise/testwise 0.2.0-beta.22 → 0.2.4

package/Testwise.ts

@@ -1,7 +1,6 @@
 import { test as base } from '@playwright/test';
 import { test as bddBase } from 'playwright-bdd';
 import { Components, GoToDeepLink, LoginFeatures, UserSimulation } from './page-extensions/index.js';
-import { SubjectProvider } from './page-extensions/SubjectProvider.js';
 import { SubjectRegistry } from './page-extensions/SubjectRegistry.js';
 import { WaitEventHandler } from './page-extensions/WaitEventHandler.js';
 import { ClickOverride } from './page-overrides/ClickOverride.js';
@@ -23,8 +22,7 @@ const extensions = [
   LoginFeatures,
   UserSimulation,
   WaitEventHandler,
-  SubjectRegistry,
-  SubjectProvider
+  SubjectRegistry
 ];
 
 export const test: Test = combineExtensions(base, ...extensions);

package/artifact-builder/InterfaceGenerator.ts

@@ -4,17 +4,19 @@ import { fileURLToPath } from 'node:url';
 import * as prettier from 'prettier';
 import { FetchingJSONSchemaStore, InputData, JSONSchemaInput, quicktype } from 'quicktype-core';
 import { PathResolver } from '../helpers/PathResolver.js';
-import { NamingHandler } from '../index.js';
+import { DataRetriever, NamingHandler } from '../index.js';
 
 export class InterfaceGenerator {
   private readonly _namingHandler: NamingHandler;
   private _filename: string;
   private _dirname: string;
+  private _screensToBuild: string[];
 
   constructor() {
     this._namingHandler = new NamingHandler();
     this._filename = fileURLToPath(import.meta.url);
     this._dirname = path.dirname(this._filename);
+    this._screensToBuild = new DataRetriever().getScreensToBuild();
   }
 
   public async generateScreenInterfacesFromSchemas() {
@@ -137,6 +139,12 @@ export class InterfaceGenerator {
       }
 
       if (schemaType === SchemaType.Screen) {
+        const fileNameSnakeCase = this._namingHandler.pascalToSnakeCase(fileName);
+
+        if (this._screensToBuild.length > 0 && !this._screensToBuild.includes(fileNameSnakeCase)) {
+          return Promise.resolve(true);
+        }
+
         const perFileOutputPath = path.join(outputPath, `I${fileName}.ts`);
         return this.createInterfaceFromSchema(schemasDirectory, perFileOutputPath, file, true);
       }

package/artifact-builder/ModelDataBuilder.ts

@@ -3,11 +3,11 @@
 /** biome-ignore-all lint/suspicious/noExplicitAny: Because I can */
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import axios from 'axios';
 import type { IProperty } from '../interfaces/IProperty.js';
-import { testwiseConfig } from '../services/ConfigBuilder.js';
+import { indiciumApi } from '../services/IndiciumApi.service.js';
 import { DataRetriever } from './helpers/DataRetriever.js';
 
+// ToDo: move this to a types folder
 type Subjects = {
   subject: string;
   variant: string;
@@ -16,30 +16,15 @@ type Subjects = {
   properties?: IProperty[];
 };
 
-const serviceUrl: string = testwiseConfig().get<string>('environmentSettings.serviceUrl')!.replace(/\/$/, '');
-const metaEndpoint: string = testwiseConfig()
-  .get<string>('environmentSettings.metaEndpoint')!
-  .replace(/^\//, '')
-  .replace(/\/$/, '');
-const authUser: string = testwiseConfig().get<string>('environmentSettings.authUser')!;
-const authUserPassword: string = testwiseConfig().get<string>('environmentSettings.authUserPassword')!;
-
-const axiosInstance = axios.create({
-  baseURL: serviceUrl,
-  headers: {
-    Authorization: `Basic ${Buffer.from(`${authUser}:${authUserPassword}`).toString('base64')}`,
-    accept: '*/*'
-  }
-});
-
-const guiApplId: number = await getGuiApplId();
-
 export async function buildSubjects() {
-  const response = await axiosInstance.get(`/iam/${metaEndpoint}/i_ui_tab?$filter=gui_appl_id%20eq%20${guiApplId}`);
+  if (!(await indiciumApi.canConnectToProject())) {
+    console.log('Cannot connect to Indicium API. Aborting subject build.');
+    return;
+  }
 
-  const rawTabs: any[] = response.data?.value || [];
+  const rawTables: any[] = await indiciumApi.getAllTables();
 
-  const subjects: Subjects[] = rawTabs
+  const subjects: Subjects[] = rawTables
     .flatMap((tab: any) => {
       const base = {
         subject: tab.tab_id,
@@ -49,15 +34,23 @@ export async function buildSubjects() {
       return [
         { ...base, screentype_id: tab.main_screen_type_id, screentype_context: 'main' },
         { ...base, screentype_id: tab.detail_screen_type_id, screentype_context: 'detail' },
-        { ...base, screentype_id: tab.zoom_screen_type_id, screentype_context: 'zoom' },
-        { ...base, screentype_id: tab.popup_screen_type_id, screentype_context: 'popup' }
+        { ...base, screentype_id: tab.popup_screen_type_id, screentype_context: 'popup' },
+        { ...base, screentype_id: tab.zoom_screen_type_id, screentype_context: 'zoom' }
       ];
     })
     .filter((item) => item.screentype_id !== 'not_visible_in_gui');
 
-  const colResponse = await axiosInstance.get(`/iam/${metaEndpoint}/i_ui_col?$filter=gui_appl_id%20eq%20${guiApplId}`);
+  const screentypeOrder = ['main', 'detail', 'popup', 'zoom'];
 
-  const allProperties: IPropertyWithSubjectIdentifiers[] = colResponse.data?.value.map((col: any) => ({
+  subjects.sort((a, b) => {
+    return (
+      a.subject.localeCompare(b.subject) ||
+      a.variant.localeCompare(b.variant) ||
+      screentypeOrder.indexOf(a.screentype_context) - screentypeOrder.indexOf(b.screentype_context)
+    );
+  });
+
+  const allProperties: IPropertyWithSubjectIdentifiers[] = (await indiciumApi.getAllColumns()).map((col: any) => ({
     subject: col.tab_id,
     variant: col.tab_variant_id,
     col: col.col_id,
@@ -69,8 +62,10 @@ export async function buildSubjects() {
       (prop) => prop.subject === subject.subject && prop.variant === subject.variant
     );
 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    subject.properties = matchingProperties.map(({ subject, variant, ...rest }) => rest);
+    subject.properties = matchingProperties
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .map(({ subject, variant, ...rest }) => rest)
+      .sort((a, b) => a.col.localeCompare(b.col));
   }
 
   const subjectsWithLookupsSet = await setLookupDropdowns(subjects);
@@ -83,11 +78,7 @@ export async function buildSubjects() {
 }
 
 async function setLookupDropdowns(subjects: Subjects[]): Promise<Subjects[]> {
-  const response = await axiosInstance.get(
-    `/iam/${metaEndpoint}/i_ui_tab_look_up?$filter=gui_appl_id%20eq%20${guiApplId}`
-  );
-
-  const lookupMappings: any[] = response.data?.value || [];
+  const lookupMappings: any[] = await indiciumApi.getLookups();
 
   for (const mapping of lookupMappings) {
     const targetSubject = subjects.find(
@@ -105,11 +96,12 @@ async function setLookupDropdowns(subjects: Subjects[]): Promise<Subjects[]> {
 }
 
 export async function buildScreens() {
-  const response = await axiosInstance.get(
-    `/iam/${metaEndpoint}/i_ui_screen_component?$filter=gui_appl_id eq ${guiApplId}`
-  );
+  if (!(await indiciumApi.canConnectToProject())) {
+    console.log('Cannot connect to Indicium API. Aborting screen build.');
+    return;
+  }
 
-  const rawComponents = response.data?.value || [];
+  const rawComponents = await indiciumApi.getScreenComponents();
   const screenMap = new Map<string, any>();
 
   for (const item of rawComponents) {
@@ -166,28 +158,7 @@ export async function buildScreens() {
   console.log('Screen schemas generated successfully.');
 }
 
-async function getGuiApplId(): Promise<number> {
-  const guiApplAlias = testwiseConfig().get<string>('environmentSettings.guiApplAlias');
-
-  if (guiApplAlias) {
-    const response = await axiosInstance.get(`/iam/${metaEndpoint}/i_ui_gui_appl`);
-    const guiAppl = response.data?.value.find((appl: any) => {
-      const currentAlias = appl?.gui_appl_alias?.toString();
-      const targetAlias = guiApplAlias?.toString();
-
-      return currentAlias === targetAlias;
-    });
-
-    if (guiAppl) {
-      return guiAppl.gui_appl_id;
-    } else {
-      throw new Error(`No GUI Application found for GUI Application Alias: ${guiApplAlias}`);
-    }
-  } else {
-    throw new Error('GUI Application Alias is not defined in the configuration.');
-  }
-}
-
+// ToDo: move this to a interfaces folder
 interface IPropertyWithSubjectIdentifiers extends IProperty {
   subject: string;
   variant: string;

package/artifact-builder/ModelDataRefiner.ts

@@ -8,10 +8,16 @@ export class ModelDataRefiner {
 
   public run() {
     const seedDataDir = this._dataRetriever.getSeedDataDirectory();
+    const subjectsToBuildPath = path.resolve(seedDataDir, 'subjectsToBuild.json');
+    const screensToBuildPath = path.resolve(seedDataDir, 'screensToBuild.json');
     const registeredSubjects: IRegisteredSubjects[] | null = this._dataRetriever.getRegisteredSubjects();
 
     if (!registeredSubjects || registeredSubjects.length === 0) {
       console.info('No registered subjects found.');
+
+      if (fs.existsSync(screensToBuildPath)) fs.unlinkSync(screensToBuildPath);
+      if (fs.existsSync(subjectsToBuildPath)) fs.unlinkSync(subjectsToBuildPath);
+
       return;
     }
 
@@ -26,14 +32,12 @@ export class ModelDataRefiner {
       )
     );
 
-    const subjectsToBuildPath = path.resolve(seedDataDir, 'subjectsToBuild.json');
     fs.writeFileSync(subjectsToBuildPath, JSON.stringify(subjectsToBuild, null, 2));
     console.log(`Created subjectsToBuild.json with ${subjectsToBuild.length} subjects.`);
 
-    const screensToBuild = Array.from(new Set(subjectsToBuild.map((subject) => subject.screentype_id)));
+    const screensToBuildList = Array.from(new Set(subjectsToBuild.map((subject) => subject.screentype_id)));
 
-    const screensToBuildPath = path.resolve(seedDataDir, 'screensToBuild.json');
-    fs.writeFileSync(screensToBuildPath, JSON.stringify(screensToBuild, null, 2));
-    console.log(`Created screensToBuild.json with ${screensToBuild.length} screens.`);
+    fs.writeFileSync(screensToBuildPath, JSON.stringify(screensToBuildList, null, 2));
+    console.log(`Created screensToBuild.json with ${screensToBuildList.length} screens.`);
   }
 }

package/artifact-builder/SelectorBuilder.ts

@@ -53,7 +53,14 @@ export class SelectorBuilder {
   }
 
   public getPageLocatorString(property: string, componentName: SubjectComponents): string {
-    const elementId = this._namingHandler.getIdFromElementName(property);
+    let elementId = this._namingHandler.getIdFromElementName(
+      property,
+      componentName,
+      this._namingHandler.getElementTypeFromElementName(property)
+    );
+
+    if (componentName === 'Grid') elementId = elementId.replace(/-/g, '_');
+
     const selectorPrefix = this.getDefaultPrefix(componentName);
     const defaultSuffix = this.getDefaultSuffix(componentName);
     const selectorSuffix = this.determineSelectorSuffix(property, componentName) || defaultSuffix;

package/artifact-builder/SubjectComponentGenerator.ts

@@ -85,6 +85,10 @@ export class SubjectComponentGenerator {
       this.addComponentImports(componentFile, componentName);
       this.setSubjectExtendsComponent(componentFile, componentName);
 
+      if (componentName === 'Grid') {
+        this.transformGridInterface(componentFile);
+      }
+
       const interfaceMatches: RegExpMatchArray | null = componentFile.content.match(/export interface (\w+) extends/);
 
       if (interfaceMatches) {
@@ -92,16 +96,29 @@ export class SubjectComponentGenerator {
         const matchingProperties = this.getPropertyNamesFromInterface(componentFile, mainInterface);
         let propertyDeclarations = '';
         let assignments = '';
+        let gridGetters = '';
 
         if (matchingProperties?.[1]) {
           const propertyLines: string[] = this.convertStringsToArray(matchingProperties[1]);
 
-          propertyDeclarations = this.generatePropertyDeclarations(propertyLines);
-
-          assignments = this.getPropertyInitializations(propertyLines, componentName);
+          if (componentName === 'Grid') {
+            gridGetters = this.generateGridGetters(propertyLines, componentName);
+          } else {
+            propertyDeclarations = this.generatePropertyDeclarations(propertyLines, componentName);
+            if (componentName === 'Form') this.transformLookupTypes(componentFile);
+            assignments = this.getPropertyInitializations(propertyLines, componentName);
+            this.addLookupImportIfRequired(componentFile);
+          }
         }
 
-        componentFile.content += `\nexport class ${mainInterface}Component extends ${componentName} implements ${mainInterface} {\n${propertyDeclarations}\n\n  constructor(page: Page, context: Locator | null = null) {\n    super(page, context);\n${assignments}\n  }\n}\n`;
+        const classBody =
+          componentName === 'Grid'
+            ? `\nexport class ${mainInterface}Component extends ${componentName} implements ${mainInterface} {\n\n` +
+              `  constructor(page: Page, context: Locator | null = null) {\n    super(page, context);\n  }\n\n${gridGetters}}\n`
+            : `\nexport class ${mainInterface}Component extends ${componentName} implements ${mainInterface} {\n${propertyDeclarations}\n\n` +
+              `  constructor(page: Page, context: Locator | null = null) {\n    super(page, context);\n${assignments}\n  }\n}\n`;
+
+        componentFile.content += classBody;
       }
 
       const subjectMatch: RegExpMatchArray | null = componentDirPath.match(/subjects[/](\w+)[/]/);
@@ -113,7 +130,6 @@ export class SubjectComponentGenerator {
         const fileName = path.basename(componentDirPath);
 
         this.verifyDirectoryExists(subjectFolder);
-
         fs.writeFileSync(path.join(subjectFolder, fileName), componentFile.content, 'utf-8');
       } else {
         fs.writeFileSync(componentDirPath, componentFile.content, 'utf-8');
@@ -121,6 +137,26 @@ export class SubjectComponentGenerator {
     }
   }
 
+  private transformGridInterface(componentFile: { content: string }): void {
+    const interfaceRegex = /export interface \w+ extends Grid \{([\s\S]*?)\}/g;
+
+    componentFile.content = componentFile.content.replace(interfaceRegex, (match, body) => {
+      const transformedBody = body.replace(/(\w+)\s*:\s*Locator(?:\[\])?;/g, 'readonly $1: Promise<Locator[]>;');
+      return match.replace(body, transformedBody);
+    });
+  }
+
+  private generateGridGetters(propertyLines: string[], componentName: SubjectComponents): string {
+    return propertyLines
+      .map((line) => {
+        const property = line.replace('readonly', '').split(':')[0].trim();
+        const pageLocatorString = this._selectorBuilder.getPageLocatorString(property, componentName);
+
+        return `  get ${property}(): Promise<Locator[]> {\n    return this.${pageLocatorString}.all();\n  }\n`;
+      })
+      .join('\n');
+  }
+
   private getSubjectFolderPath(formattedSubjectName: string): string {
     return path.resolve(
       this._currentDirname,
@@ -139,20 +175,54 @@ export class SubjectComponentGenerator {
       .map((line) => {
         const property = line.split(':')[0].replace(/\?$/, '').trim();
         const pageLocatorString = this._selectorBuilder.getPageLocatorString(property, componentName);
+
+        if (componentName === 'Form' && property.endsWith('Lookup')) {
+          return `    this.${property} = createLookupDropdown(${pageLocatorString});`;
+        }
+
         return `    this.${property} = ${pageLocatorString};`;
       })
       .join('\n');
   }
 
-  private generatePropertyDeclarations(propertiesToConvert: string[]): string {
+  private addLookupImportIfRequired(componentFile: { content: string }): void {
+    const lookupType = 'ILookupDropdown';
+    const lookupImport =
+      "import { createLookupDropdown, type ILookupDropdown } from '../../../../controls/LookupDropdown.js';";
+
+    if (componentFile.content.includes(lookupType) && !componentFile.content.includes(lookupImport)) {
+      componentFile.content = `${lookupImport}\n${componentFile.content}`;
+    }
+  }
+
+  private generatePropertyDeclarations(propertiesToConvert: string[], componentName: SubjectComponents): string {
     return propertiesToConvert
       .map((line) => {
         const property = line.replace(/^\s+/, '').split(':')[0].replace(/\?$/, '').trim();
-        return `  ${property}!: Locator;`;
+
+        if (componentName === 'Form' && property.endsWith('Lookup')) {
+          return `  ${property}: ILookupDropdown;`;
+        }
+
+        return `  ${property}: Locator;`;
       })
       .join('\n');
   }
 
+  private transformLookupTypes(componentFile: { content: string }): void {
+    const interfaceRegex = /export interface \w+ extends Form \{([\s\S]*?)\}/g;
+
+    componentFile.content = componentFile.content.replace(interfaceRegex, (match, interfaceBody) => {
+      const propertyRegex = /(\w+Lookup)\s*:\s*Locator;/g;
+
+      const updatedBody = interfaceBody.replace(propertyRegex, (_propMatch: string, propName: string) => {
+        return `${propName}: ILookupDropdown;`;
+      });
+
+      return match.replace(interfaceBody, updatedBody);
+    });
+  }
+
   private convertStringsToArray(content: string): string[] {
     return content
       .split('\n')

package/artifact-builder/SubjectGenerator.ts

@@ -82,7 +82,7 @@ export class SubjectGenerator {
     const subjectFolderPath = this.getSubjectFolderRelativePath(subjectFolderName);
 
     const subjectClass = {
-      content: `import type { Page } from '@playwright/test';\nimport { SubjectPageBase } from '../../index.js';\n`,
+      content: `import type { Page } from '@playwright/test';\nimport { SubjectPageBase } from '../../SubjectPageBase.js';\n`,
       name: this._namingHandler.generateSubjectClassName(subject)
     };
     const componentDictionary: { name: string; type: SubjectAgnosticComponents; context: string }[] =

package/artifact-builder/SubjectRegistration.ts

@@ -2,50 +2,45 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import * as prettier from 'prettier';
 
 export class SubjectRegistration {
-  private static readonly SUBJECTS_RELATIVE_PATH = 'test-artifacts/subjects';
   private static readonly IMPORT_MATCH_REGEX = /import .*'\.\.\/test-artifacts\/subjects\/index\.js';\n?/g;
 
   private readonly _currentFilename: string;
   private readonly _currentDirname: string;
   private readonly _subjectTypePath: string;
-  private readonly _subjectBuilderPath: string;
 
   constructor() {
     this._currentFilename = fileURLToPath(import.meta.url);
     this._currentDirname = dirname(this._currentFilename);
     this._subjectTypePath = path.resolve(this._currentDirname, '../../page-extensions/SubjectRegistry.ts');
-    this._subjectBuilderPath = path.resolve(this._currentDirname, '../../page-extensions/SubjectProvider.ts');
   }
 
   public run(): void {
-    this.registerGeneratedSubjectsAsSubjectTypes();
-    this.registerGeneratedSubjectsUnderPageGet();
+    const subjectDetails = this.getAllSubjectDetails();
+
+    this.registerGeneratedSubjectsAsSubjectTypes(subjectDetails);
   }
 
-  private registerGeneratedSubjectsAsSubjectTypes(): void {
-    const subjectList = this.getAllSubjects();
-    const subjectTypeImportsAndExports = this.getSubjectTypesImportsAndExports(subjectList);
+  private async registerGeneratedSubjectsAsSubjectTypes(subjectDetails: SubjectDetail[]): Promise<void> {
+    const subjectTypeImportsAndExports = this.buildSubjectTypeExport(subjectDetails);
     const subject = { content: this.setSubjectTypeContent() };
 
     this.removeExistingSubjectTypeDefinition(subject);
     this.removeAllImportsFromSubjectIndex(subject);
 
     subject.content = subjectTypeImportsAndExports + subject.content;
-    fs.writeFileSync(this._subjectTypePath, subject.content, 'utf-8');
-  }
-
-  private registerGeneratedSubjectsUnderPageGet(): void {
-    const subjectNames = this.getAllSubjects();
-    const subjectBuilder = { content: fs.readFileSync(this._subjectBuilderPath, 'utf-8') };
+    subject.content = this.addPathRecordsToContent(subject.content, subjectDetails);
 
-    this.removeSubjectBuilderImports(subjectBuilder);
-    this.removeSubjectBuilderSubjectDefinition(subjectBuilder);
-    this.addSubjectBuilderImports(subjectNames, subjectBuilder);
-    this.addSubjectBuilderSubjectDefinition(subjectNames, subjectBuilder);
+    const formattedContent = await prettier.format(subject.content, {
+      parser: 'typescript',
+      singleQuote: true,
+      semi: true,
+      trailingComma: 'all'
+    });
 
-    fs.writeFileSync(this._subjectBuilderPath, subjectBuilder.content, 'utf-8');
+    fs.writeFileSync(this._subjectTypePath, formattedContent, 'utf-8');
   }
 
   private removeExistingSubjectTypeDefinition(subject: { content: string }): void {
@@ -66,12 +61,15 @@ export class SubjectRegistration {
     }
   }
 
-  private getSubjectTypesImportsAndExports(subjectList: string[]): string {
-    const importLine = `import type { ${subjectList.join(', ')} } from '../${SubjectRegistration.SUBJECTS_RELATIVE_PATH}/index.js';`;
-    const subjectTypeEntries = subjectList.map((name) => `  ${name}: typeof ${name};`).join('\n    ');
-    const newSubjectTypes = `${importLine}
-
-  export type SubjectType = {
+  private buildSubjectTypeExport(subjectDetails: SubjectDetail[]): string {
+    const subjectTypeEntries = subjectDetails
+      .map(
+        (details) =>
+          `  ${details.subject}${details.variant ?? ''}${details.screen}: ` +
+          `Promise<import('../test-artifacts/subjects/${details.subject}/index.js').${details.subject}${details.variant ?? ''}${details.screen}>;`
+      )
+      .join('\n    ');
+    const newSubjectTypes = `export type SubjectType = {
   ${subjectTypeEntries}
   };
   `;
@@ -79,53 +77,68 @@ export class SubjectRegistration {
     return newSubjectTypes;
   }
 
-  private getAllSubjects(): string[] {
+  private addPathRecordsToContent(content: string, subjectDetails: SubjectDetail[]): string {
+    const pathRecordsString = this.buildPathRecordsString(subjectDetails);
+    const stringToMatch = "none: ''";
+    return content.replace(stringToMatch, `\n${pathRecordsString}\n    `);
+  }
+
+  private buildPathRecordsString(subjectDetails: SubjectDetail[]): string {
+    return subjectDetails
+      .map(
+        (details) =>
+          `  ${details.subject}${details.variant ?? ''}${details.screen}: ` +
+          `'../test-artifacts/subjects/${details.subject}/index.js',`
+      )
+      .join('\n    ');
+  }
+
+  private getAllSubjectDetails(): SubjectDetail[] {
     const subjectsDir = path.resolve(this._currentDirname, '../../test-artifacts/subjects');
 
     const subjectFolders = fs.readdirSync(subjectsDir).filter((file) => {
       return fs.statSync(path.join(subjectsDir, file)).isDirectory();
     });
 
-    const subjectNames: string[] = [];
+    const subjectDetails: SubjectDetail[] = [];
+    const seenFullNames = new Set<string>();
 
     subjectFolders.forEach((folder) => {
       const folderPath = path.join(subjectsDir, folder);
-      const tsFiles = fs.readdirSync(folderPath).filter((file) => file.endsWith('.ts'));
+      const tsFiles = fs.readdirSync(folderPath).filter((file) => file.endsWith('.ts') && file !== 'index.ts');
 
       tsFiles.forEach((tsFile) => {
         const classContent = fs.readFileSync(path.join(folderPath, tsFile), 'utf-8');
         const classMatches = classContent.matchAll(/export\s+class\s+(\w+)/g);
+
         for (const match of classMatches) {
-          subjectNames.push(match[1]);
+          const className = match[1];
+          const pattern = new RegExp(`^(${folder})(.*)(Main|Popup|Zoom|Detail)$`);
+          const variantMatch = className.match(pattern);
+
+          if (variantMatch) {
+            const fullName = variantMatch[0];
+            if (!seenFullNames.has(fullName)) {
+              const variant = variantMatch[2] || '';
+              const screen = variantMatch[3] as SubjectDetail['screen'];
+
+              subjectDetails.push({
+                subject: folder,
+                variant: variant,
+                screen: screen
+              });
+              seenFullNames.add(fullName);
+            }
+          }
         }
       });
     });
-    return subjectNames;
-  }
-
-  private addSubjectBuilderSubjectDefinition(subjectNames: string[], subjectBuilder: { content: string }): void {
-    const pageSubjectDefinition = `page.subject = {\n${subjectNames.map((name) => `    ${name},`).join('\n')}\n};\n`;
-
-    subjectBuilder.content = subjectBuilder.content.replace(
-      /(\/\/ page\.subject definition goes here\n)/,
-      `$1        ${pageSubjectDefinition}        `
-    );
-  }
-
-  private removeSubjectBuilderSubjectDefinition(subjectBuilder: { content: string }): void {
-    subjectBuilder.content = subjectBuilder.content.replace(/page\.subject\s*=\s*{[\s\S]*?};\s*/m, '');
-  }
-
-  private addSubjectBuilderImports(subjectNames: string[], subjectBuilder: { content: string }): void {
-    const importLine = `import { ${subjectNames.join(', ')} } from '../${SubjectRegistration.SUBJECTS_RELATIVE_PATH}/index.js';`;
-
-    subjectBuilder.content = subjectBuilder.content.replace(
-      /(import type { Test } from '\.\.\/types\/Test\.js';)/,
-      `$1\n${importLine}`
-    );
+    return subjectDetails;
   }
+}
 
-  private removeSubjectBuilderImports(subjectBuilder: { content: string }): void {
-    subjectBuilder.content = subjectBuilder.content.replace(SubjectRegistration.IMPORT_MATCH_REGEX, '');
-  }
+export interface SubjectDetail {
+  subject: string;
+  variant?: string;
+  screen: 'Main' | 'Popup' | 'Zoom' | 'Detail';
 }

package/artifact-builder/helpers/DataRetriever.ts

@@ -19,8 +19,10 @@ export class DataRetriever {
 
   public getRegisteredSubjects(): IRegisteredSubjects[] | null {
     const registeredSubjectsPath = path.join(this._consumerRootDirectory, 'seed-data/registeredSubjects.json');
+
     if (!fs.existsSync(registeredSubjectsPath)) {
-      console.error(`Seed data file not found at: ${registeredSubjectsPath}`);
+      console.info(`Seed data file not found at: ${registeredSubjectsPath}`);
+
       return null;
     }
 
@@ -43,7 +45,8 @@ export class DataRetriever {
   public getScreensToBuild(): string[] {
     const screensToBuildPath = path.join(this._consumerRootDirectory, 'seed-data/screensToBuild.json');
     if (!fs.existsSync(screensToBuildPath)) {
-      console.info(`screensToBuild.json not found at: ${screensToBuildPath}. Using all screens as fallback.`);
+      console.info(`screensToBuild.json not found.`);
+      return [];
     }
 
     const json = fs.readFileSync(screensToBuildPath, 'utf-8');