@team-codeme/crud-forge 0.0.0-stage → 1.0.0

package/src/templates/fuse-packs/access-control-tools/lib/hierarchy-scanner.test.js

@@ -0,0 +1,323 @@
+'use strict';
+
+/**
+ * Regression tests for hierarchy scanner + TS AST component index.
+ * Run: node src/app/domains/admin/modules/apps/shared/access-control-tools/lib/hierarchy-scanner.test.js
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const assert = require('assert');
+const { extractComponentsFromFile, buildComponentCatalog } = require('./ts-component-index');
+const { buildScreenNavigationHierarchy } = require('./hierarchy-scanner');
+
+const ORIGINAL_UNRESOLVED_SELECTORS = [
+  'app-geo-location-details',
+  'app-approval-type-dropdown',
+  'app-damage-loss-record-form',
+  'app-geo-location-map',
+  'app-geo-map',
+  'app-role-header',
+  'app-role-users',
+  'app-role-inheritance',
+  'app-role-permissions',
+  'app-paddy-stock-summary',
+  'app-table',
+  'app-about-building-card',
+  'app-atti-cards-list-card',
+  'app-capacity-details-card',
+  'app-manager-profile-card',
+  'app-assigned-staff-card',
+  'app-warehouse-audit-card',
+  'app-lease-details-card',
+  'app-warehouse-details-card',
+  'app-assigned-buildings-card',
+  'app-atti-card-summary-card',
+];
+
+function write(file, content) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content, 'utf8');
+}
+
+function testMultiComponentAstIndex() {
+  const source = `
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-damage-loss-record-form',
+  templateUrl: './form.html',
+  standalone: true,
+  imports: [],
+})
+export class DamageLossRecordFormComponent {
+  readonly SCREEN = 'damage-loss-record-form';
+}
+
+@Component({
+  selector: 'app-damage-action-choice-dialog',
+  template: '<p>dialog</p>',
+  standalone: true,
+})
+export class DamageActionChoiceDialogComponent {}
+`;
+  const comps = extractComponentsFromFile('/virtual/form.component.ts', source);
+  assert.strictEqual(comps.length, 2, 'indexes both @Component declarations');
+  const form = comps.find((c) => c.selector === 'app-damage-loss-record-form');
+  assert.ok(form, 'form selector present');
+  assert.strictEqual(form.screenId, 'damage-loss-record-form');
+  assert.strictEqual(form.className, 'DamageLossRecordFormComponent');
+  const dialog = comps.find((c) => c.selector === 'app-damage-action-choice-dialog');
+  assert.ok(dialog);
+  assert.strictEqual(dialog.screenId, null);
+  console.log('✓ multi-component AST index');
+}
+
+function testSkipsInputScreenPassthrough() {
+  const source = `
+import { Component, Input } from '@angular/core';
+@Component({ selector: 'app-about-warehouse-card', template: '', standalone: true })
+export class AboutWarehouseCard {
+  @Input() SCREEN: string = 'warehouse-detail';
+}
+@Component({ selector: 'app-warehouse-detail', templateUrl: './x.html', standalone: true })
+export class WarehouseDetailComponent {
+  readonly SCREEN = 'warehouse-detail';
+}
+`;
+  const comps = extractComponentsFromFile('/virtual/pages/warehouse-details/x.ts', source);
+  const card = comps.find((c) => c.className === 'AboutWarehouseCard');
+  const page = comps.find((c) => c.className === 'WarehouseDetailComponent');
+  assert.strictEqual(card.screenId, null, '@Input() SCREEN is not own screen id');
+  assert.strictEqual(page.screenId, 'warehouse-detail');
+  console.log('✓ skips @Input() SCREEN host passthrough');
+}
+
+function testHierarchyResolvesEmbedAndWithoutScreen() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ac-hier-'));
+  const appsRoot = path.join(root, 'apps');
+  const pages = path.join(appsRoot, 'pages', 'demo');
+  const shared = path.join(appsRoot, 'shared', 'components', 'widget');
+  const mf = path.join(appsRoot, 'micro-functions', 'demoModule', 'entities', 'item', 'form');
+
+  write(
+    path.join(pages, 'host-page.component.ts'),
+    `
+import { Component } from '@angular/core';
+@Component({
+  selector: 'app-host-page',
+  templateUrl: './host-page.component.html',
+  standalone: true,
+})
+export class HostPageComponent {
+  readonly SCREEN = 'host-page';
+}
+`
+  );
+  write(
+    path.join(pages, 'host-page.component.html'),
+    `
+<app-item-form></app-item-form>
+<app-shared-widget></app-shared-widget>
+<app-totally-missing></app-totally-missing>
+`
+  );
+  write(
+    path.join(mf, 'item-form.component.ts'),
+    `
+import { Component } from '@angular/core';
+@Component({
+  selector: 'app-item-form',
+  template: '<button>save</button>',
+  standalone: true,
+})
+export class ItemFormComponent {
+  readonly SCREEN = 'item-form';
+}
+`
+  );
+  write(
+    path.join(shared, 'shared-widget.component.ts'),
+    `
+import { Component } from '@angular/core';
+@Component({
+  selector: 'app-shared-widget',
+  template: '<span>w</span>',
+  standalone: true,
+})
+export class SharedWidgetComponent {}
+`
+  );
+  write(
+    path.join(appsRoot, 'demo.routes.ts'),
+    `
+export const routes = [
+  { path: 'host', component: HostPageComponent },
+  { path: 'lazy', loadComponent: () => import('./pages/demo/host-page.component').then(m => m.HostPageComponent) },
+];
+`
+  );
+
+  const hierarchy = buildScreenNavigationHierarchy({
+    workItems: [
+      {
+        tsFile: path.join(pages, 'host-page.component.ts'),
+        className: 'HostPageComponent',
+        screenId: 'host-page',
+        screenName: 'I-Host',
+        templateContent: fs.readFileSync(path.join(pages, 'host-page.component.html'), 'utf8'),
+        htmlPath: path.join(pages, 'host-page.component.html'),
+        fileContent: fs.readFileSync(path.join(pages, 'host-page.component.ts'), 'utf8'),
+        sourceType: 'pages',
+      },
+    ],
+    appsRoot,
+    adminRoutesFile: null,
+  });
+
+  assert.ok(hierarchy.pages.length >= 1, 'host page emitted');
+  const page = hierarchy.pages.find((p) => p.hostScreenId === 'host-page');
+  assert.ok(page, 'host-page entry');
+  assert.ok(
+    page.embeddedScreens.some((e) => e.screenId === 'item-form'),
+    'item-form embedded'
+  );
+  assert.ok(
+    !page.embeddedScreens.some((e) => e.screenId === 'app-shared-widget'),
+    'does not invent SCREEN for shared widget'
+  );
+  assert.ok(
+    hierarchy.resolvedWithoutScreen.some((r) => r.selector === 'app-shared-widget'),
+    'shared widget classified resolvedWithoutScreen'
+  );
+  assert.ok(
+    hierarchy.unresolved.some((u) => u.selector === 'app-totally-missing'),
+    'missing selector stays unresolved'
+  );
+  assert.ok(
+    !hierarchy.unresolved.some((u) => u.selector === 'app-shared-widget'),
+    'resolved widgets are not unresolved'
+  );
+
+  // Multi-parent: same embed under second host must not merge permissions (separate page entries)
+  write(
+    path.join(pages, 'other-page.component.ts'),
+    `
+import { Component } from '@angular/core';
+@Component({
+  selector: 'app-other-page',
+  templateUrl: './other-page.component.html',
+  standalone: true,
+})
+export class OtherPageComponent {
+  readonly SCREEN = 'other-page';
+}
+`
+  );
+  write(path.join(pages, 'other-page.component.html'), `<app-item-form></app-item-form>`);
+
+  const again = buildScreenNavigationHierarchy({
+    workItems: [
+      {
+        tsFile: path.join(pages, 'host-page.component.ts'),
+        className: 'HostPageComponent',
+        screenId: 'host-page',
+        screenName: 'I-Host',
+        templateContent: fs.readFileSync(path.join(pages, 'host-page.component.html'), 'utf8'),
+        htmlPath: path.join(pages, 'host-page.component.html'),
+        fileContent: '',
+        sourceType: 'pages',
+      },
+      {
+        tsFile: path.join(pages, 'other-page.component.ts'),
+        className: 'OtherPageComponent',
+        screenId: 'other-page',
+        screenName: 'I-Other',
+        templateContent: `<app-item-form></app-item-form>`,
+        htmlPath: path.join(pages, 'other-page.component.html'),
+        fileContent: '',
+        sourceType: 'pages',
+      },
+    ],
+    appsRoot,
+    adminRoutesFile: null,
+  });
+  const hosts = again.pages.filter((p) =>
+    p.embeddedScreens.some((e) => e.screenId === 'item-form')
+  );
+  assert.ok(hosts.length >= 2, 'reusable form listed under multiple parents');
+  assert.notStrictEqual(hosts[0].hostScreenId, hosts[1].hostScreenId);
+
+  // Idempotency
+  const third = buildScreenNavigationHierarchy({
+    workItems: again.pages.length
+      ? [
+          {
+            tsFile: path.join(pages, 'host-page.component.ts'),
+            className: 'HostPageComponent',
+            screenId: 'host-page',
+            screenName: 'I-Host',
+            templateContent: fs.readFileSync(path.join(pages, 'host-page.component.html'), 'utf8'),
+            htmlPath: path.join(pages, 'host-page.component.html'),
+            fileContent: '',
+            sourceType: 'pages',
+          },
+          {
+            tsFile: path.join(pages, 'other-page.component.ts'),
+            className: 'OtherPageComponent',
+            screenId: 'other-page',
+            screenName: 'I-Other',
+            templateContent: `<app-item-form></app-item-form>`,
+            htmlPath: path.join(pages, 'other-page.component.html'),
+            fileContent: '',
+            sourceType: 'pages',
+          },
+        ]
+      : [],
+    appsRoot,
+    adminRoutesFile: null,
+  });
+  assert.strictEqual(third.stats.embedEdgeCount, again.stats.embedEdgeCount);
+  assert.strictEqual(third.stats.unresolvedCount, again.stats.unresolvedCount);
+  assert.strictEqual(third.pages.length, again.pages.length);
+
+  fs.rmSync(root, { recursive: true, force: true });
+  console.log('✓ hierarchy embed / without-screen / multi-parent / idempotent');
+}
+
+function testCatalogPrefersScreenOwnerForSelector() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ac-cat-'));
+  const appsRoot = path.join(root, 'apps');
+  const dir = path.join(appsRoot, 'micro-functions', 'x', 'entities', 'y', 'form');
+  write(
+    path.join(dir, 'multi.component.ts'),
+    `
+import { Component } from '@angular/core';
+@Component({ selector: 'app-form', template: '', standalone: true })
+export class FormComponent { readonly SCREEN = 'the-form'; }
+@Component({ selector: 'app-dialog', template: '', standalone: true })
+export class DialogComponent {}
+`
+  );
+  const catalog = buildComponentCatalog([path.join(appsRoot, 'micro-functions')]);
+  assert.strictEqual(catalog.bySelector.get('app-form')?.screenId, 'the-form');
+  fs.rmSync(root, { recursive: true, force: true });
+  console.log('✓ catalog selector prefers SCREEN owner');
+}
+
+function testOriginalSelectorsDocumented() {
+  assert.strictEqual(ORIGINAL_UNRESOLVED_SELECTORS.length, 21);
+  console.log('✓ original unresolved selector baseline documented (21 unique / 36 rows)');
+}
+
+function main() {
+  testMultiComponentAstIndex();
+  testSkipsInputScreenPassthrough();
+  testCatalogPrefersScreenOwnerForSelector();
+  testHierarchyResolvesEmbedAndWithoutScreen();
+  testOriginalSelectorsDocumented();
+  console.log('\nAll hierarchy scanner regression tests passed.');
+}
+
+main();

package/src/templates/fuse-packs/access-control-tools/lib/html-scanner.js

@@ -0,0 +1,362 @@
+'use strict';
+
+const {
+  resolveComponentId,
+  toQaId,
+  ensureUniqueId,
+  deduceComponentName,
+  deduceComponentType,
+  generateComponentDescription,
+} = require('./id-rules');
+
+function hasAttribute(tagContent, attributeName) {
+  return new RegExp(`\\s${attributeName}\\s*=`).test(tagContent);
+}
+
+function setOrReplaceAttribute(tagContent, name, value) {
+  const pattern = new RegExp(`\\s${name}\\s*=\\s*(["'])([^"']*)\\1`, 'i');
+  if (pattern.test(tagContent)) {
+    return tagContent.replace(pattern, ` ${name}="${value}"`);
+  }
+  const tagNameMatch = tagContent.match(/^<([a-zA-Z0-9-]+)/);
+  if (!tagNameMatch) {
+    return tagContent;
+  }
+  return tagContent.replace(tagNameMatch[0], `${tagNameMatch[0]} ${name}="${value}"`);
+}
+
+function injectAccessCtrlIntoTag(tagContent, componentId, options = {}) {
+  const { rewriteIds = false } = options;
+  const accessCtrlCheck = `SCREEN | accessCtrl: '${componentId}'`;
+  const existing = tagContent.match(/accessCtrl\s*:\s*['"]([^'"]+)['"]/);
+
+  if (existing) {
+    if (!rewriteIds || existing[1] === componentId) {
+      return { tag: tagContent, accessCtrlId: existing[1], changed: false };
+    }
+    const updated = tagContent.replace(
+      /accessCtrl\s*:\s*['"][^'"]+['"]/,
+      `accessCtrl: '${componentId}'`
+    );
+    return { tag: updated, accessCtrlId: componentId, changed: updated !== tagContent };
+  }
+
+  const ngIfDoubleQuote = tagContent.match(/\*ngIf\s*=\s*"([^"]+)"/);
+  const ngIfSingleQuote = tagContent.match(/\*ngIf\s*=\s*'([^']+)'/);
+
+  let updated = tagContent;
+  if (ngIfDoubleQuote) {
+    const existingCondition = ngIfDoubleQuote[1];
+    if (!existingCondition.includes('accessCtrl')) {
+      updated = tagContent.replace(
+        /\*ngIf\s*=\s*"([^"]+)"/,
+        `*ngIf="${existingCondition} && (${accessCtrlCheck})"`
+      );
+    }
+  } else if (ngIfSingleQuote) {
+    const existingCondition = ngIfSingleQuote[1];
+    if (!existingCondition.includes('accessCtrl')) {
+      updated = tagContent.replace(
+        /\*ngIf\s*=\s*'([^']+)'/,
+        `*ngIf='${existingCondition} && (${accessCtrlCheck})'`
+      );
+    }
+  } else {
+    const tagNameMatch = tagContent.match(/^<([a-zA-Z0-9-]+)/);
+    if (tagNameMatch) {
+      updated = tagContent.replace(tagNameMatch[0], `${tagNameMatch[0]} *ngIf="${accessCtrlCheck}"`);
+    }
+  }
+
+  return { tag: updated, accessCtrlId: componentId, changed: updated !== tagContent };
+}
+
+function isInteractiveTag(tagContent) {
+  const tagNameMatch = tagContent.match(/^<([a-zA-Z0-9-]+)/);
+  if (!tagNameMatch) {
+    return false;
+  }
+  const tagName = tagNameMatch[1].toLowerCase();
+  const hasClick =
+    tagContent.includes('(click)=') ||
+    tagContent.includes('on-click=') ||
+    tagContent.includes('[click]=');
+  const hasMatButton = /mat-(raised-|icon-|stroked-|flat-|mini-)?button/i.test(tagContent);
+  const hasRouterLink = /routerLink\s*=|\[routerLink\]\s*=/.test(tagContent);
+  const hasButtonRole = /role\s*=\s*["']button["']/.test(tagContent);
+  const isSubmit = /\btype\s*=\s*["']submit["']/i.test(tagContent);
+
+  if (tagName === 'button' || hasMatButton || hasRouterLink || hasButtonRole || isSubmit) {
+    return true;
+  }
+
+  // Non-button containers only if they have a click
+  if (hasClick) {
+    const skipContainers = new Set([
+      'span',
+      'div',
+      'mat-icon',
+      'p',
+      'h1',
+      'h2',
+      'h3',
+      'h4',
+      'h5',
+      'h6',
+      'form',
+      'mat-form-field',
+      'mat-label',
+      'mat-select',
+      'mat-option',
+      'input',
+      'textarea',
+      'table',
+      'tr',
+      'td',
+      'th',
+      'ul',
+      'li',
+      'section',
+      'header',
+      'footer',
+      'main',
+      'nav',
+    ]);
+    // Allow clickable cards/links; skip pure chrome containers unless they look intentional
+    if (skipContainers.has(tagName) && !/cursor-pointer|role\s*=\s*["']button["']/.test(tagContent)) {
+      // Still process if it's clearly an action wrapper with meaningful click — resolveComponentId will noise-filter
+      return true;
+    }
+    return true;
+  }
+
+  return false;
+}
+
+function hasOtherStructuralDirective(tagContent) {
+  return /\*(?!ngIf)[a-zA-Z0-9]+/.test(tagContent);
+}
+
+function stripAccessCtrlFromTag(tagContent) {
+  let updated = tagContent;
+
+  // *ngIf="SCREEN | accessCtrl: 'x'" → remove whole *ngIf if only accessCtrl
+  updated = updated.replace(/\s*\*ngIf\s*=\s*"SCREEN\s*\|\s*accessCtrl:\s*'[^']+'"/g, '');
+  updated = updated.replace(/\s*\*ngIf\s*=\s*'SCREEN\s*\|\s*accessCtrl:\s*"[^"]+"'/g, '');
+
+  // *ngIf="foo && (SCREEN | accessCtrl: 'x')" → *ngIf="foo"
+  updated = updated.replace(
+    /(\*ngIf\s*=\s*")([^"]*?)\s*&&\s*\(SCREEN\s*\|\s*accessCtrl:\s*'[^']+'\)(")/g,
+    '$1$2$3'
+  );
+  updated = updated.replace(
+    /(\*ngIf\s*=\s*")([^"]*?)\s*&&\s*\(SCREEN\s*\|\s*accessCtrl:\s*"[^"]+"\)(")/g,
+    '$1$2$3'
+  );
+  // leading accessCtrl && rest
+  updated = updated.replace(
+    /(\*ngIf\s*=\s*")\(SCREEN\s*\|\s*accessCtrl:\s*'[^']+'\)\s*&&\s*/g,
+    '$1'
+  );
+
+  return updated;
+}
+
+function stripQaAttrsFromTag(tagContent) {
+  let updated = tagContent;
+  for (const name of ['data-qa-id', 'data-component-id', 'data-screen-id', 'id']) {
+    const pattern = new RegExp(`\\s${name}\\s*=\\s*(["'])[^"']*\\1`, 'i');
+    // Only strip id when it looks like a qa- id
+    if (name === 'id') {
+      updated = updated.replace(/\sid\s*=\s*(["'])qa-[^"']*\1/i, '');
+    } else {
+      updated = updated.replace(pattern, '');
+    }
+  }
+  return updated;
+}
+
+/**
+ * Process one opening tag for access-control + QA attrs.
+ *
+ * @returns {{ modifiedTag, tagChanged, skipped, skipReason, discovery }}
+ */
+function processTag(tagContent, screenId, screenName, usedIds, options = {}) {
+  const { injectAccess = true, injectQa = true, rewriteIds = false } = options;
+
+  if (!isInteractiveTag(tagContent)) {
+    return { modifiedTag: tagContent, tagChanged: false, skipped: true, skipReason: 'not-interactive' };
+  }
+
+  // Angular: multiple structural directives on one element is illegal
+  if (hasOtherStructuralDirective(tagContent) && injectAccess) {
+    // Still allow QA-only attrs on *ngFor buttons
+    if (!injectQa) {
+      return { modifiedTag: tagContent, tagChanged: false, skipped: true, skipReason: 'structural-directive' };
+    }
+  }
+
+  let componentId = resolveComponentId(tagContent, screenId, { rewriteIds });
+  if (!componentId) {
+    // On rewrite, strip previously injected noise ids from the tag
+    if (rewriteIds && (/accessCtrl\s*:/.test(tagContent) || /data-qa-id\s*=/.test(tagContent) || /\sid\s*=\s*["']qa-/.test(tagContent))) {
+      let cleaned = tagContent;
+      cleaned = stripAccessCtrlFromTag(cleaned);
+      cleaned = stripQaAttrsFromTag(cleaned);
+      return {
+        modifiedTag: cleaned,
+        tagChanged: cleaned !== tagContent,
+        skipped: true,
+        skipReason: 'noise-stripped',
+      };
+    }
+    return { modifiedTag: tagContent, tagChanged: false, skipped: true, skipReason: 'noise-or-unresolved' };
+  }
+
+  componentId = ensureUniqueId(componentId, usedIds);
+
+  let updated = tagContent;
+  let changed = false;
+  let accessCtrlId = componentId;
+
+  const canInjectAccess =
+    injectAccess && !hasOtherStructuralDirective(tagContent);
+
+  if (canInjectAccess) {
+    const accessResult = injectAccessCtrlIntoTag(updated, componentId, { rewriteIds });
+    updated = accessResult.tag;
+    accessCtrlId = accessResult.accessCtrlId || componentId;
+    if (accessResult.changed) {
+      changed = true;
+    }
+  }
+
+  if (injectQa) {
+    const qaId = toQaId(screenId, componentId);
+    const attrs = [
+      ['data-screen-id', screenId],
+      ['data-component-id', componentId],
+      ['data-qa-id', qaId],
+    ];
+    // Prefer data-qa-id as primary selector; only set id= when missing to reduce *ngFor collisions
+    if (!hasAttribute(updated, 'id') || rewriteIds) {
+      attrs.push(['id', qaId]);
+    }
+
+    for (const [name, value] of attrs) {
+      const before = updated;
+      const existingMatch = updated.match(new RegExp(`\\s${name}\\s*=\\s*(["'])([^"']*)\\1`, 'i'));
+      const shouldWrite =
+        rewriteIds ||
+        !existingMatch ||
+        (name === 'data-screen-id' && existingMatch[2] !== value);
+
+      if (shouldWrite) {
+        updated = setOrReplaceAttribute(updated, name, value);
+      }
+      if (updated !== before) {
+        changed = true;
+      }
+    }
+  }
+
+  const componentName = deduceComponentName(componentId, screenId);
+  const componentType = deduceComponentType(componentId, screenId);
+  const discovery = {
+    screenName,
+    screenId,
+    componentName,
+    componentId,
+    componentType,
+    description: generateComponentDescription(componentId, componentName, componentType, screenId),
+  };
+
+  return {
+    modifiedTag: updated,
+    tagChanged: changed,
+    skipped: false,
+    discovery,
+  };
+}
+
+function parseHtmlAndInject(htmlContent, screenId, screenName, options = {}) {
+  let result = '';
+  let index = 0;
+  let insideTag = false;
+  let quoteChar = null;
+  let tagStart = 0;
+  let modified = false;
+  const usedIds = new Set();
+  const discoveries = [];
+  const skipped = [];
+
+  while (index < htmlContent.length) {
+    const char = htmlContent[index];
+
+    if (!insideTag) {
+      if (char === '<') {
+        if (htmlContent.startsWith('<!--', index)) {
+          const commentEnd = htmlContent.indexOf('-->', index);
+          if (commentEnd !== -1) {
+            result += htmlContent.substring(index, commentEnd + 3);
+            index = commentEnd + 3;
+          } else {
+            result += htmlContent.substring(index);
+            index = htmlContent.length;
+          }
+          continue;
+        }
+
+        if (htmlContent[index + 1] === '/') {
+          result += char;
+          index++;
+          continue;
+        }
+
+        insideTag = true;
+        quoteChar = null;
+        tagStart = index;
+        index++;
+      } else {
+        result += char;
+        index++;
+      }
+    } else if (quoteChar) {
+      if (char === quoteChar && htmlContent[index - 1] !== '\\') {
+        quoteChar = null;
+      }
+      index++;
+    } else if (char === '"' || char === "'") {
+      quoteChar = char;
+      index++;
+    } else if (char === '>') {
+      insideTag = false;
+      const tagContent = htmlContent.substring(tagStart, index + 1);
+      const processed = processTag(tagContent, screenId, screenName, usedIds, options);
+      if (processed.tagChanged) {
+        modified = true;
+      }
+      if (processed.discovery) {
+        discoveries.push(processed.discovery);
+      }
+      if (processed.skipped && processed.skipReason === 'noise-or-unresolved') {
+        skipped.push({ reason: processed.skipReason, snippet: tagContent.slice(0, 120) });
+      }
+      result += processed.modifiedTag;
+      index++;
+    } else {
+      index++;
+    }
+  }
+
+  return { html: result, modified, discoveries, skipped };
+}
+
+module.exports = {
+  parseHtmlAndInject,
+  processTag,
+  isInteractiveTag,
+  hasOtherStructuralDirective,
+  injectAccessCtrlIntoTag,
+  setOrReplaceAttribute,
+};