@thinkwise/testwise 0.2.62 → 0.2.99

package/artifact-builder/TsFileSerializer.ts

@@ -0,0 +1,247 @@
+import { IndentationText, Project, QuoteKind, Scope, type SourceFile, StructureKind } from 'ts-morph';
+import type { SubjectComponents } from '../types/Components.js';
+import type { ComponentClassModel, TsFileModel } from './TsFileModel.js';
+
+/**
+ * Converts in-memory TypeScript file models (`TsFileModel`, `ComponentClassModel`)
+ * into formatted TypeScript source strings using `ts-morph` AST manipulation.
+ *
+ * **Why ts-morph instead of string templates:** String-template code generation
+ * is fragile — it breaks on quoting, indentation, and special characters.
+ * `ts-morph` builds a real AST and prints it, so the output is always
+ * syntactically valid and consistently formatted.
+ *
+ * **Exported functions:**
+ * - `serializeTsFile(model)` — writes a complete subject class file from a
+ *   `TsFileModel` (used by `SubjectGenerator`).
+ * - `appendComponentClass(existingContent, model)` — appends a typed component
+ *   class body to an existing interface file (used by `SubjectComponentGenerator`).
+ * - `refineComponentInterface(rawContent, componentType)` — post-processes a
+ *   raw quicktype interface file (adds Testwise imports, removes `Locator` base).
+ */
+
+function createProject(existingContent?: string): { project: Project; file: SourceFile } {
+  const project = new Project({
+    useInMemoryFileSystem: true,
+    skipAddingFilesFromTsConfig: true,
+    manipulationSettings: {
+      indentationText: IndentationText.TwoSpaces,
+      quoteKind: QuoteKind.Single
+    }
+  });
+  const file = project.createSourceFile('output.ts', existingContent ?? '');
+  return { project, file };
+}
+
+/** Builds a subject class file from a typed model. No string templates. */
+export function serializeTsFile(model: TsFileModel): string {
+  const { file } = createProject();
+
+  for (const imp of model.imports) {
+    file.addImportDeclaration({
+      isTypeOnly: imp.isTypeOnly,
+      namedImports: imp.namedImports.map((n) => ({ name: n.name, isTypeOnly: n.isTypeOnly ?? false })),
+      moduleSpecifier: imp.from
+    });
+  }
+
+  const cls = model.classModel;
+
+  file.addClass({
+    name: cls.name,
+    extends: cls.extendsClass,
+    implements: [cls.implementsInterface],
+    isExported: true,
+    properties: cls.properties.map((p) => ({
+      kind: StructureKind.Property as const,
+      scope: p.access === 'private' ? Scope.Private : undefined,
+      name: p.name,
+      type: p.type
+    })),
+    ctors: [
+      {
+        parameters: cls.constructor.params.map((p) => ({ name: p.name, type: p.type })),
+        statements: [
+          `super(${cls.constructor.superCall});`,
+          ...cls.constructor.assignments.map((a) => `this.${a.property} = ${a.value};`),
+          ...cls.constructor.extraLines
+        ]
+      }
+    ],
+    methods: (cls.methods ?? []).map((m) => ({
+      scope: Scope.Public,
+      isAsync: m.isAsync,
+      name: m.name,
+      statements: m.bodyLines
+    }))
+  });
+
+  return file.print();
+}
+
+/**
+ * Parses an existing component interface file, appends the component class and
+ * any required control imports, and returns the complete printed file.
+ * Replaces string-template-based class body generation — no string templates.
+ */
+export function appendComponentClass(existingContent: string, model: ComponentClassModel): string {
+  const { file } = createProject(existingContent);
+
+  addControlImports(file, model);
+
+  const contextProp = {
+    kind: StructureKind.Property as const,
+    scope: Scope.Private,
+    name: '_context',
+    type: 'Locator'
+  };
+
+  if (model.componentType === 'Grid') {
+    file.addClass({
+      name: `${model.interfaceName}Component`,
+      extends: model.componentType,
+      implements: [model.interfaceName],
+      isExported: true,
+      properties: [contextProp],
+      ctors: [
+        {
+          parameters: [{ name: 'context', type: 'Locator' }],
+          statements: ['super(context);', 'this._context = context;']
+        }
+      ],
+      getAccessors: model.getters.map((g) => ({
+        scope: Scope.Public,
+        name: g.name,
+        returnType: g.returnType,
+        statements: [g.bodyLine]
+      }))
+    });
+  } else {
+    file.addClass({
+      name: `${model.interfaceName}Component`,
+      extends: model.componentType,
+      implements: [model.interfaceName],
+      isExported: true,
+      properties: [contextProp, ...model.properties.map((p) => ({ name: p.name, type: p.type }))],
+      ctors: [
+        {
+          parameters: [{ name: 'context', type: 'Locator' }],
+          statements: [
+            'super(context);',
+            'this._context = context;',
+            ...model.assignments.map((a) => `this.${a.property} = ${a.value};`)
+          ]
+        }
+      ]
+    });
+  }
+
+  return file.print();
+}
+
+// ── Control import resolution ──────────────────────────────────────────────
+
+const controlImportMap: Record<string, { createFn: string; moduleSpecifier: string }> = {
+  ILookupDropdown: {
+    createFn: 'createLookupDropdown',
+    moduleSpecifier: '../../../../controls/LookupDropdown.js'
+  },
+  IFormComboBox: {
+    createFn: 'createFormComboBox',
+    moduleSpecifier: '../../../../controls/FormComboBox.js'
+  },
+  IInputFieldControl: {
+    createFn: 'createInputFieldControl',
+    moduleSpecifier: '../../../../controls/InputFieldControl.js'
+  },
+  IDateControl: {
+    createFn: 'createDateControl',
+    moduleSpecifier: '../../../../controls/DateControl.js'
+  }
+};
+
+function addControlImports(file: SourceFile, model: ComponentClassModel): void {
+  const usedTypes = new Set(model.properties.map((p) => p.type));
+
+  for (const [typeName, { createFn, moduleSpecifier }] of Object.entries(controlImportMap)) {
+    if (!usedTypes.has(typeName)) continue;
+
+    const alreadyImported = file.getImportDeclarations().some((d) => d.getModuleSpecifierValue() === moduleSpecifier);
+    if (alreadyImported) continue;
+
+    file.addImportDeclaration({
+      namedImports: [{ name: createFn }, { name: typeName, isTypeOnly: true }],
+      moduleSpecifier
+    });
+  }
+}
+
+// ── Form property-type suffix mapping ─────────────────────────────────────
+
+const formTypeSuffixMap: Record<string, string> = {
+  Lookup: 'ILookupDropdown',
+  ComboBox: 'IFormComboBox',
+  Field: 'IInputFieldControl',
+  DatePicker: 'IDateControl'
+};
+
+/**
+ * Transforms a raw quicktype-generated interface file into a refined component
+ * interface file using ts-morph AST manipulation — no string templates.
+ *
+ * Replaces the five string-manipulation methods previously in SubjectComponentGenerator:
+ * removeLocatorInterface, addComponentImports, setSubjectExtendsComponent,
+ * transformGridInterface, transformInterfaceTypes.
+ */
+export function refineComponentInterface(rawContent: string, componentType: SubjectComponents): string {
+  const { file } = createProject(rawContent);
+
+  // Remove the stray Locator interface that quicktype emits alongside the real schema
+  file.getInterface('Locator')?.remove();
+
+  // Prepend the imports this component type needs
+  file.insertImportDeclarations(0, [
+    {
+      namedImports: [{ name: componentType }],
+      moduleSpecifier: '../../../../components/index.js'
+    },
+    ...(componentType === 'Grid'
+      ? [
+          {
+            namedImports: [{ name: 'createGridColumnControl' }, { name: 'IGridColumnControl', isTypeOnly: true }],
+            moduleSpecifier: '../../../../controls/GridColumnControl.js'
+          }
+        ]
+      : []),
+    {
+      isTypeOnly: true,
+      namedImports: [{ name: 'Locator' }],
+      moduleSpecifier: '@playwright/test'
+    }
+  ]);
+
+  // Find the main interface (no extends clause yet) and make it extend the component
+  const mainInterface = file.getInterfaces().find((i) => i.getExtends().length === 0);
+  if (mainInterface) {
+    mainInterface.addExtends(componentType);
+
+    if (componentType === 'Grid') {
+      // Swap every Locator-typed property for a readonly IGridColumnControl
+      for (const prop of mainInterface.getProperties()) {
+        const typeText = prop.getTypeNode()?.getText() ?? '';
+        if (typeText === 'Locator' || typeText === 'Locator[]') {
+          prop.setIsReadonly(true);
+          prop.setType('IGridColumnControl');
+        }
+      }
+    } else {
+      // Map Form property name suffixes to their control types
+      for (const prop of mainInterface.getProperties()) {
+        const suffix = Object.keys(formTypeSuffixMap).find((s) => prop.getName().endsWith(s));
+        if (suffix) prop.setType(formTypeSuffixMap[suffix]);
+      }
+    }
+  }
+
+  return file.print();
+}

package/artifact-builder/helpers/DataRetriever.ts

@@ -1,67 +1,104 @@
 import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { PathResolver } from '../../helpers/PathResolver.js';
 import type { IRegisteredSubjects } from '../../interfaces/IRegisteredSubjects.js';
 import type { ISubject } from '../../interfaces/ISubject.js';
+import { PipelinePaths } from './PipelinePaths.js';
 
+/**
+ * Thin file-system accessor that reads all JSON seed-data files used by the
+ * artifact-builder pipeline and returns them as typed objects.
+ *
+ * **What it does:** Abstracts away all `fs.readFileSync` / JSON.parse calls so
+ * that pipeline steps only deal with typed data, never raw file I/O. All path
+ * resolution is delegated to `PipelinePaths` — there are no hardcoded paths here.
+ *
+ * **Why it exists as a separate class:** Injecting `DataRetriever` into each
+ * pipeline step makes the steps unit-testable without touching the real
+ * filesystem. Tests pass a `DataRetriever` constructed with a fake
+ * `PipelinePaths` that points to a temp directory.
+ *
+ * **For contributors:** If the pipeline gains a new seed-data file, add a
+ * typed accessor method here (and a corresponding path getter to
+ * `PipelinePaths`).
+ */
 export class DataRetriever {
-  private _consumerRootDirectory: string = new PathResolver().getConsumerRootDirectory();
+  private readonly _paths: PipelinePaths;
+
+  constructor(paths?: PipelinePaths) {
+    /* v8 ignore next -- default only used at runtime, not in unit tests */
+    this._paths = paths ?? new PipelinePaths();
+  }
 
   public getSubjectsSeedData(): ISubject[] {
-    const seedPath = path.join(this._consumerRootDirectory, 'seed-data/subjects.json');
+    const seedPath = this._paths.subjectsJson;
+
     if (!fs.existsSync(seedPath)) {
-      console.error(`Seed data file not found at: ${seedPath}`);
+      throw new Error(`subjects.json not found at: ${seedPath}. Run the model data build step first.`);
     }
 
-    const json = fs.readFileSync(seedPath, 'utf-8');
-    return this.toISubject(json) as unknown as ISubject[];
+    return this.parseJsonFile<ISubject[]>(seedPath);
   }
 
   public getRegisteredSubjects(): IRegisteredSubjects[] | null {
-    const registeredSubjectsPath = path.join(this._consumerRootDirectory, 'seed-data/registeredSubjects.json');
+    const registeredSubjectsPath = this._paths.registeredSubjectsJson;
 
     if (!fs.existsSync(registeredSubjectsPath)) {
-      console.info(`Seed data file not found at: ${registeredSubjectsPath}`);
-
+      console.info(`registeredSubjects.json not found at: ${registeredSubjectsPath}. No subjects are registered.`);
       return null;
     }
 
-    const json = fs.readFileSync(registeredSubjectsPath, 'utf-8');
-    return this.toIRegisteredSubjects(json) as unknown as IRegisteredSubjects[];
+    return this.parseJsonFile<IRegisteredSubjects[]>(registeredSubjectsPath);
   }
 
   public getSubjectsToBuild(): ISubject[] {
-    const subjectsToBuildPath = path.join(this._consumerRootDirectory, 'seed-data/subjectsToBuild.json');
-    if (!fs.existsSync(subjectsToBuildPath)) {
-      console.info(`subjectsToBuild.json not found at: ${subjectsToBuildPath}. Using all subjects as fallback.`);
+    const subjectsToBuildPath = this._paths.subjectsToBuildJson;
 
+    if (!fs.existsSync(subjectsToBuildPath)) {
+      console.info(`subjectsToBuild.json not found – falling back to full subjects seed data.`);
       return this.getSubjectsSeedData();
     }
 
-    const json = fs.readFileSync(subjectsToBuildPath, 'utf-8');
-    return this.toISubject(json) as unknown as ISubject[];
+    return this.parseJsonFile<ISubject[]>(subjectsToBuildPath);
   }
 
   public getScreensToBuild(): string[] {
-    const screensToBuildPath = path.join(this._consumerRootDirectory, 'seed-data/screensToBuild.json');
+    const screensToBuildPath = this._paths.screensToBuildJson;
+
     if (!fs.existsSync(screensToBuildPath)) {
-      console.info(`screensToBuild.json not found.`);
+      console.info(`screensToBuild.json not found – all screens will be processed.`);
       return [];
     }
 
-    const json = fs.readFileSync(screensToBuildPath, 'utf-8');
-    return JSON.parse(json) as string[];
+    return this.parseJsonFile<string[]>(screensToBuildPath);
   }
 
-  public getSeedDataDirectory(): string {
-    return path.join(this._consumerRootDirectory, 'seed-data');
+  public getScreenComponentMeta(screenTypeId: string): Record<string, string> {
+    const schemaPath = `${this._paths.screenSchemas}/${screenTypeId}.json`;
+
+    if (!fs.existsSync(schemaPath)) return {};
+
+    const schema = this.parseJsonFile<{ properties?: Record<string, unknown> }>(schemaPath);
+    const result: Record<string, string> = {};
+
+    for (const originalId of Object.keys(schema.properties ?? {})) {
+      // Normalize to lowercase-alphanumeric so the lookup is insensitive to
+      // camelCase variations between change-case and quicktype's nice-property-names.
+      const normalizedKey = originalId.toLowerCase().replace(/[^a-z0-9]/g, '');
+      result[normalizedKey] = originalId;
+    }
+
+    return result;
   }
 
-  private toISubject(json: string): ISubject {
-    return JSON.parse(json);
+  public getSeedDataDirectory(): string {
+    return this._paths.seedData;
   }
 
-  private toIRegisteredSubjects(json: string): IRegisteredSubjects {
-    return JSON.parse(json);
+  private parseJsonFile<T>(filePath: string): T {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    try {
+      return JSON.parse(raw) as T;
+    } catch (cause) {
+      throw new Error(`Failed to parse JSON at ${filePath}: ${(cause as Error).message}`);
+    }
   }
 }

package/artifact-builder/helpers/NamingHandler.ts

@@ -1,8 +1,24 @@
 import * as path from 'node:path';
 import { pascalCase, snakeCase } from 'change-case';
 import { KnownElementTypes } from '../../enums/ElementTypes.js';
-import type { ScreenComponents, SubjectComponents } from '../../types/Components.js';
-
+import type { SubjectComponents } from '../../types/Components.js';
+
+/**
+ * Centralises all naming and string-transformation logic used by the
+ * artifact-builder pipeline.
+ *
+ * **What it does:**
+ * - Converts subject/variant/screentype tuples into the correct PascalCase
+ *   class names that are written to the generated subject files.
+ * - Maps `control_type` strings from the Indicium API to the Testwise control
+ *   class suffix that appears in generated component interfaces
+ *   (e.g. `"lookup"` → `"Lookup"` → property name ends in `Lookup`).
+ * - Handles edge cases like `Form` vs `Grid` defaults and multi-variant naming.
+ *
+ * **For contributors:** If the Thinkwise model introduces a new control type
+ * that should map to a different Testwise control, add it to the mapping
+ * matrix inside `getElementSuffixFromControlTypeAndComponentType`.
+ */
 export class NamingHandler {
   public getDefaultElementSuffixFromComponentType(componentType: SubjectComponents): KnownElementTypes {
     const controlTypeMapping: Record<SubjectComponents, KnownElementTypes> = {
@@ -47,49 +63,6 @@ export class NamingHandler {
     ).toLowerCase();
   }
 
-  public getIdFromElementName(elementName: string, componentType: SubjectComponents, controlType: string): string {
-    const elementSuffixToRemove = this.getElementSuffixFromControlTypeAndComponentType(controlType, componentType);
-    const elementSuffixToRemoveFormatted = elementSuffixToRemove.replace(/_/g, '-').toLowerCase();
-
-    let id = this.toSnakeCase(elementName)
-      .replace(/([a-z])([A-Z])/g, '$1-$2')
-      .toLowerCase()
-      .replace(/_/g, '-');
-
-    if (elementSuffixToRemove) {
-      const suffixRegex = new RegExp(`-?${elementSuffixToRemoveFormatted}$`, 'i');
-      id = id.replace(suffixRegex, '');
-    }
-
-    return id.replace(/-+/g, '-').replace(/-+$/g, '');
-  }
-
-  public getComponentTypeFromFileName(fileName: string): SubjectComponents {
-    // ToDo: use this
-    const match = fileName.match(/([A-Z][a-z]+)(?=\.ts$)/);
-    if (match) {
-      const componentName = match[1];
-      if (componentName === 'Form') return 'Form';
-      if (componentName === 'Grid') return 'Grid';
-    }
-    throw new Error(`Unknown component type in file name: ${fileName}`);
-  }
-
-  public getElementTypeFromElementName(elementName: string): string {
-    const snakeCaseElementName = this.toSnakeCase(elementName);
-    const parts = snakeCaseElementName.split('_');
-
-    for (let i = parts.length - 1; i > 0; i--) {
-      const candidate = parts.slice(i).join('_');
-
-      if (Object.values(KnownElementTypes).includes(candidate as KnownElementTypes)) {
-        return candidate;
-      }
-    }
-
-    throw new Error(`No KnownElementType match found for a partial suffix of "${elementName}"`);
-  }
-
   public getSubjectFromFileName(fileName: string): string {
     return fileName.replace(/([A-Z][a-z0-9]*)$/, '');
   }
@@ -102,6 +75,10 @@ export class NamingHandler {
     return pascalCase(name);
   }
 
+  public toSubjectPascalCase(name: string): string {
+    return this.toPascalCase(name.replace(/_(\d)/g, '$1'));
+  }
+
   public formatPropertyName(name: string): string {
     return name.charAt(0).toLowerCase() + name.slice(1);
   }
@@ -114,45 +91,13 @@ export class NamingHandler {
     return snakeCase(value);
   }
 
-  public getComponentIdFromName(componentName: string, componentType: ScreenComponents): string {
-    if (componentType === 'ActionBar' || componentType === 'CustomActionBar') {
-      const capitalizedComponentName = this.capitalizeFirstLetter(componentName);
-      return capitalizedComponentName.replace(/Toolbar/, 'Toolbar_');
-    }
-
-    if (componentType === 'Splitter') {
-      const componentId = componentName.toLowerCase();
-
-      if (/^splitter\d+$/.test(componentId)) {
-        return componentId;
-      }
-
-      return componentId.replace(/splitter/, 'splitter-');
-    }
-
-    if (componentType === 'Tab') {
-      return this.capitalizeFirstLetter(componentName);
-    }
-
-    return componentName;
-  }
-
   public capitalizeFirstLetter(value: string): string {
     return value.charAt(0).toUpperCase() + value.slice(1);
   }
 
-  public getTabParentFromComponentName(componentName: string): string {
-    const match = componentName.match(/^[a-z0-9]+(?=[A-Z])/);
-    if (match) {
-      return match[0];
-    }
-
-    throw new Error(`Could not extract tab parent from component name: ${componentName}`);
-  }
-
   public generateSubjectClassName(subject: { subject: string; screentype_context: string; variant: string }): string {
     const uniqueSubjectIdentifier = subject.variant !== '' ? `${subject.subject}_${subject.variant}` : subject.subject;
     const className = `${uniqueSubjectIdentifier}_${subject.screentype_context}`;
-    return this.toPascalCase(className);
+    return this.toSubjectPascalCase(className);
   }
 }

package/artifact-builder/helpers/PipelinePaths.ts

@@ -0,0 +1,123 @@
+import * as path from 'node:path';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { PathResolver } from '../../helpers/PathResolver.js';
+
+// Resolved once at module load so every PipelinePaths instance shares
+// the same package root without re-computing it on construction.
+const _moduleFilename = fileURLToPath(import.meta.url);
+const _moduleDirname = dirname(_moduleFilename);
+
+// dist/artifact-builder/helpers → dist/artifact-builder → dist → package-root
+const packageRoot = path.resolve(_moduleDirname, '../../..');
+
+/**
+ * Single source of truth for all filesystem paths used by the artifact-builder
+ * pipeline.
+ *
+ * - Generated seed data (subjects.json, screen-schemas) lives under the
+ *   **package root** (`node_modules/@thinkwise/testwise/seed-data/`) because
+ *   it is rebuilt on every sync and can safely be regenerated.
+ * - `registeredSubjects.json` lives in the **consumer project root** because
+ *   it represents the user's curated subject list and must never be lost when
+ *   `node_modules` is wiped and reinstalled.
+ */
+export class PipelinePaths {
+  private readonly _packageRoot: string;
+  private readonly _consumerRoot: string;
+
+  constructor() {
+    this._packageRoot = packageRoot;
+    /* v8 ignore next -- PathResolver walks the real filesystem; exercised via integration */
+    this._consumerRoot = new PathResolver().getConsumerRootDirectory();
+  }
+
+  // ── Package root – seed data ─────────────────────────────────────────────
+
+  /** `<package>/seed-data/` */
+  get seedData(): string {
+    return path.join(this._packageRoot, 'seed-data');
+  }
+
+  /** `<consumer>/seed-data/screen-schemas/` */
+  get screenSchemas(): string {
+    return path.join(this.seedData, 'screen-schemas');
+  }
+
+  /** `<consumer>/seed-data/subjects.json` */
+  get subjectsJson(): string {
+    return path.join(this.seedData, 'subjects.json');
+  }
+
+  /** `<consumer>/seed-data/subjectsToBuild.json` */
+  get subjectsToBuildJson(): string {
+    return path.join(this.seedData, 'subjectsToBuild.json');
+  }
+
+  /** `<consumer>/seed-data/screensToBuild.json` */
+  get screensToBuildJson(): string {
+    return path.join(this.seedData, 'screensToBuild.json');
+  }
+
+  /** `<consumer>/seed-data/registeredSubjects.json` – lives in the consumer project so it survives `npm install` */
+  get registeredSubjectsJson(): string {
+    return path.join(this._consumerRoot, 'seed-data', 'registeredSubjects.json');
+  }
+
+  // ── Package root – generated artifacts ─────────────────────────────────
+
+  /** `<package>/test-artifacts/` */
+  get testArtifacts(): string {
+    return path.join(this._packageRoot, 'test-artifacts');
+  }
+
+  /** `<package>/test-artifacts/screens/` */
+  get screens(): string {
+    return path.join(this.testArtifacts, 'screens');
+  }
+
+  /** `<package>/test-artifacts/screens/index.ts` */
+  get screensIndex(): string {
+    return path.join(this.screens, 'index.ts');
+  }
+
+  /** `<package>/test-artifacts/subjects/` */
+  get subjects(): string {
+    return path.join(this.testArtifacts, 'subjects');
+  }
+
+  /**
+   * `<package>/dist/test-artifacts/schemas/`
+   *
+   * Intermediate JSON schemas are kept inside `dist/` so that the TypeScript
+   * compiler does not include them in compilation but they are accessible at
+   * runtime after the initial `tsc` pass.
+   */
+  get schemas(): string {
+    return path.join(this._packageRoot, 'dist', 'test-artifacts', 'schemas');
+  }
+
+  // ── Package root – source files ─────────────────────────────────────────
+
+  /** `<package>/page-extensions/SubjectRegistry.ts` */
+  get subjectRegistry(): string {
+    return path.join(this._packageRoot, 'page-extensions', 'SubjectRegistry.ts');
+  }
+
+  /** `<package>/templates/SubjectRegistry.template.ts` */
+  get subjectRegistryTemplate(): string {
+    return path.join(this._packageRoot, 'templates', 'SubjectRegistry.template.ts');
+  }
+
+  // ── Derived helpers ─────────────────────────────────────────────────────
+
+  /** `<package>/test-artifacts/subjects/<subjectName>/` */
+  subjectFolder(subjectName: string): string {
+    return path.join(this.subjects, subjectName);
+  }
+
+  /** `<package>/test-artifacts/subjects/<subjectName>/Components/` */
+  subjectComponentsFolder(subjectName: string): string {
+    return path.join(this.subjectFolder(subjectName), 'Components');
+  }
+}

package/artifact-builder/helpers/Stopwatch.ts

@@ -1,5 +1,15 @@
 import { performance } from 'node:perf_hooks';
 
+/**
+ * Minimal lap timer used to log how long each pipeline step takes.
+ *
+ * ```ts
+ * const sw = new Stopwatch();
+ * const lap = sw.start('SchemaGenerator');
+ * // ... do work ...
+ * lap.stop(); // logs: "[0.412s]: SchemaGenerator"
+ * ```
+ */
 export class Stopwatch {
   start(message: string) {
     const startTime = performance.now();

package/artifact-builder/helpers/index.ts

@@ -1,3 +1,4 @@
 export * from './DataRetriever.js';
 export * from './NamingHandler.js';
+export * from './PipelinePaths.js';
 export * from './Stopwatch.js';

package/artifact-builder/index.ts

@@ -1,9 +1,13 @@
 export * from './ArtifactManager.js';
+export * from './ComponentClassModelBuilder.js';
 export * from './helpers/index.js';
 export * from './InterfaceGenerator.js';
 export * from './ModelDataRefiner.js';
 export * from './SchemaGenerator.js';
 export * from './ScreenInterfaceRefiner.js';
+export * from './SubjectClassModelBuilder.js';
 export * from './SubjectComponentGenerator.js';
 export * from './SubjectGenerator.js';
 export * from './SubjectRegistration.js';
+export * from './TsFileModel.js';
+export * from './TsFileSerializer.js';