Power Platform QA Solution

Metadata

IDunused-controls

Result KeyunusedControls

Fileunused-controls.js

Built-inYes

Analyzer Classification

Category — This determines the type of Analyzer you are building. Categories can be set up under settings.

Test sets — Include this analyzer in predefined runs. Select one or more test sets this analyzer should belong to.

Dataverse test set Some tests

Description

Detects controls that are never referenced in any formula and have no meaningful side effects

Prompt

Not available — this analyzer was not AI-generated.

Source Code

unused-controls.js — read-only (built-in) · Input data reference ↗

Checking…

import { SIDE_EFFECT_PROPERTIES } from '../utils/constants.js';

// Control types that are structural children required by their parent (never referenced by name)
const TEMPLATE_CHILD_TYPES = new Set([
  'DataTableColumn', 'TabListDataField', 'DropDownDataField',
  'TypedDataCard', 'ComboBoxDataField', 'ListBoxDataField',
  'RadioDataField', 'DatePickerDataField', 'ToggleDataField',
]);

// Control types that exist purely for visual/layout purposes - only flag if explicitly hidden
const VISUAL_TYPES = new Set([
  'Label', 'Text', 'ModernText', 'FluentV8/Label',
  'Rectangle', 'Circle', 'Image', 'HtmlViewer',
  'Legend', 'Spinner',
]);

export function findUnusedControls(controlTree, refGraph) {
  const results = [];

  for (const node of controlTree.allNodes) {
    if (node.isApp) continue;
    if (node.isScreen) continue;
    if (node.isComponent) continue;
    if (node.isComponentInstance) continue;

    // Skip template/structural children - they are required by their parent
    if (TEMPLATE_CHILD_TYPES.has(node.baseType)) continue;

    // Skip locked template controls (gallery row templates etc.)
    if (node.isLocked) continue;

    // Check if this control is referenced anywhere
    const refs = refGraph.referencedControls.get(node.name);
    const isReferenced = refs && refs.length > 0;
    if (isReferenced) continue;

    // Check if it has meaningful side-effect handlers
    if (hasMeaningfulSideEffects(node)) continue;

    // Containers with children are structural
    if (node.children.length > 0) continue;

    const onlyVisibleTrue = hasOnlyVisibleTrue(node);

    // Visual controls that display content (even static) are "used" by being visible
    // Only flag them if they are explicitly hidden, have zero size, or are bare placeholders
    if (VISUAL_TYPES.has(node.baseType)) {
      if (!isExplicitlyHidden(node) && !hasZeroDimensions(node) && !onlyVisibleTrue) {
        continue; // Visible visual control - it's being used
      }
    }

    // Input controls (TextInput, DropDown, ComboBox, etc.) that are not referenced
    // are genuinely unused - their value is never consumed
    const confidence = onlyVisibleTrue ? 'high' : getConfidence(node);
    const reason = onlyVisibleTrue
      ? 'Empty placeholder: only Visible=true is set, no other properties configured; never referenced'
      : getReason(node);

    results.push({
      name: node.name,
      type: node.type,
      screen: node.screen,
      file: node.filePath,
      confidence,
      reason,
    });
  }

  results.sort((a, b) => {
    const order = { high: 0, medium: 1, low: 2 };
    return (order[a.confidence] - order[b.confidence]) || a.screen.localeCompare(b.screen);
  });

  return results;
}

function hasMeaningfulSideEffects(node) {
  for (const prop of SIDE_EFFECT_PROPERTIES) {
    if (node.formulas.has(prop)) {
      const formula = node.formulas.get(prop).trim();
      if (isMeaningfulFormula(formula)) {
        return true;
      }
    }
  }
  return false;
}

function isMeaningfulFormula(formula) {
  if (!formula) return false;
  const trimmed = formula.trim();
  if (trimmed === '') return false;
  if (trimmed === 'false') return false;
  if (trimmed === 'true') return false;
  if (trimmed === '""') return false;
  if (trimmed === 'Select(Parent)') return false;
  return true;
}

function hasOnlyVisibleTrue(node) {
  if (node.properties.size === 0) return false;
  for (const [key, val] of node.properties) {
    if (key !== 'Visible') return false;
    const trimmed = String(val).replace(/^=/, '').trim().toLowerCase();
    if (trimmed !== 'true') return false;
  }
  return true;
}

function isExplicitlyHidden(node) {
  const visible = node.properties.get('Visible');
  if (visible && visible.startsWith('=')) {
    const val = visible.slice(1).trim().toLowerCase();
    return val === 'false';
  }
  return false;
}

function hasZeroDimensions(node) {
  const w = node.properties.get('Width');
  const h = node.properties.get('Height');
  return (w === '=0' || h === '=0');
}

function getConfidence(node) {
  if (isExplicitlyHidden(node)) return 'high';
  if (hasZeroDimensions(node)) return 'high';
  if (!hasDynamicFormulas(node)) return 'high';
  return 'medium';
}

function hasDynamicFormulas(node) {
  for (const [propName, formula] of node.formulas) {
    if (SIDE_EFFECT_PROPERTIES.has(propName)) continue;
    if (isStaticFormula(formula)) continue;
    return true;
  }
  return false;
}

function isStaticFormula(formula) {
  const trimmed = formula.trim();
  if (/^"[^"]*"$/.test(trimmed)) return true;
  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return true;
  if (trimmed === 'true' || trimmed === 'false') return true;
  if (/^RGBA\s*\(\s*[\d.,\s]+\)$/.test(trimmed)) return true;
  if (/^Color\.\w+$/.test(trimmed)) return true;
  if (/^\w+\.\w+$/.test(trimmed)) return true;
  if (/^(Parent|Self)\.\w+/.test(trimmed)) return true;
  // Empty formula
  if (trimmed === '' || trimmed === '=') return true;
  return false;
}

export default {
  name: 'Unused Controls',
  description: 'Detects controls that are never referenced in any formula and have no meaningful side effects',
  resultKey: 'unusedControls',
  resultSchema: {
    keys: [
      { key: 'name',       label: 'Control',    suggestedFormat: 'name-copy' },
      { key: 'type',       label: 'Type',       suggestedFormat: 'code' },
      { key: 'screen',     label: 'Screen',     suggestedFormat: 'name-copy' },
      { key: 'file',       label: 'File',       suggestedFormat: 'dim' },
      { key: 'confidence', label: 'Confidence', suggestedFormat: 'badge-confidence' },
      { key: 'reason',     label: 'Reason',     suggestedFormat: 'dim' }
    ]
  },
  analyze(controlTree, refGraph, _extraction) {
    return findUnusedControls(controlTree, refGraph);
  }
};

function getReason(node) {
  const parts = [];

  if (isExplicitlyHidden(node)) {
    parts.push('Explicitly hidden (Visible=false)');
  }
  if (hasZeroDimensions(node)) {
    parts.push('Zero dimensions');
  }

  parts.push('never referenced in any formula');

  const hasAnyHandler = [...node.formulas.keys()].some(k => SIDE_EFFECT_PROPERTIES.has(k));
  if (!hasAnyHandler) {
    parts.push('no event handlers');
  } else {
    parts.push('event handlers contain only pass-through code');
  }

  return parts.join('; ');
}

Report Output Columns

Columns shown in the generated report. Toggle off to hide; pick a declared key or use "Custom…" for dot-paths like locations.0.file.

Enabled	Key	Label	Format	Width

Configure Analyzer — Unused Controls BUILT-IN

Test Unused Controls

Test results