Detect and show project issues

[danixeee]

Detect and show project issues such as:

• project has text layers that have ALL CAPS option enabled
• project contains videos / images / PDF / whatever that is not currently supported
• cinema 4D - detect and show warning, offer to convert all comps 4D to classic 3D
• expression errors
• think of other possible issues

[vladavoX]

script that some client made, we can take a look into it, and see what can be used from here

'use strict';

if (!Array.prototype.forEach) {
  Array.prototype.forEach = function (callback, thisArg) {
    if (this == null) throw new TypeError('Array.prototype.forEach called on null or undefined');
    if (typeof callback !== 'function') throw new TypeError(callback + ' is not a function');
    var O = Object(this),
      len = O.length >>> 0;
    for (var i = 0; i < len; i++) {
      if (i in O) callback.call(thisArg, O[i], i, O);
    }
  };
}
if (!String.prototype.includes) {
  String.prototype.includes = function (search, start) {
    if (typeof start !== 'number') {
      start = 0;
    }
    if (start + search.length > this.length) {
      return false;
    } else {
      return this.indexOf(search, start) !== -1;
    }
  };
}
if (!Array.prototype.find) {
  Array.prototype.find = function (predicate, thisArg) {
    if (this == null) {
      throw new TypeError('Array.prototype.find called on null or undefined');
    }
    if (typeof predicate !== 'function') {
      throw new TypeError(predicate + ' is not a function');
    }
    var list = Object(this);
    var length = list.length >>> 0;
    for (var i = 0; i < length; i++) {
      var value = list[i];
      if (predicate.call(thisArg, value, i, list)) {
        return value;
      }
    }
    return undefined;
  };
}
if (!Array.prototype.includes) {
  Array.prototype.includes = function (searchElement, fromIndex) {
    if (this == null) {
      throw new TypeError('"this" is null or not defined');
    }
    var o = Object(this);
    var len = o.length >>> 0;
    if (len === 0) {
      return false;
    }
    var n = fromIndex | 0;
    var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
    function sameValueZero(x, y) {
      return x === y || typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y);
    }
    while (k < len) {
      if (sameValueZero(o[k], searchElement)) {
        return true;
      }
      k++;
    }
    return false;
  };
}
if (!Array.isArray) {
  Array.isArray = function (arg) {
    return Object.prototype.toString.call(arg) === '[object Array]';
  };
}

/**
 * Cyrillic to Latin transliteration map.
 * This map is used for replacing Cyrillic characters with their Latin equivalents.
 * The object is frozen to prevent accidental mutation.
 */
var CYRILLIC_TO_LATIN_MAP = {
  А: 'A',
  а: 'a',
  Б: 'B',
  б: 'b',
  В: 'V',
  в: 'v',
  Г: 'G',
  г: 'g',
  Д: 'D',
  д: 'd',
  Е: 'E',
  е: 'e',
  Ё: 'E',
  ё: 'e',
  Ж: 'Zh',
  ж: 'zh',
  З: 'Z',
  з: 'z',
  И: 'I',
  и: 'i',
  Й: 'Y',
  й: 'y',
  К: 'K',
  к: 'k',
  Л: 'L',
  л: 'l',
  М: 'M',
  м: 'm',
  Н: 'N',
  н: 'n',
  О: 'O',
  о: 'o',
  П: 'P',
  п: 'p',
  Р: 'R',
  р: 'r',
  С: 'S',
  с: 's',
  Т: 'T',
  т: 't',
  У: 'U',
  у: 'u',
  Ф: 'F',
  ф: 'f',
  Х: 'Kh',
  х: 'kh',
  Ц: 'Ts',
  ц: 'ts',
  Ч: 'Ch',
  ч: 'ch',
  Ш: 'Sh',
  ш: 'sh',
  Щ: 'Shch',
  щ: 'shch',
  Ъ: '',
  ъ: '',
  Ы: 'Y',
  ы: 'y',
  Ь: '',
  ь: '',
  Э: 'E',
  э: 'e',
  Ю: 'Yu',
  ю: 'yu',
  Я: 'Ya',
  я: 'ya'
};

/*
  String utility functions for SuperCreatives Checker
  Modern ES6+ syntax
*/
var containsCyrillic = function containsCyrillic() {
  var str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
  return /[\u0400-\u04FF]/.test(str);
};
// Utility: Check for extended Unicode or non-ASCII (except allowed)
var containsInvalidUnicode = function containsInvalidUnicode() {
  var str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
  return /[^\u0020-\u007E⚡\-_.()[\]{}]/.test(str);
};
var isNameValid = function isNameValid() {
  var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
  return !containsCyrillic(name) && !containsInvalidUnicode(name);
};

// Sanitize name by removing/replacing disallowed characters based on the same pattern as isNameValid
var sanitizeInvalidName = function sanitizeInvalidName(name) {
  var res = (name || '').replace(/[\u0400-\u04FF]/g, '');
  res = res.replace(/[^\u0020-\u007E⚡\-_.()[\]{}]/g, '');
  return res;
};

/**
 * Replace Cyrillic characters in the input string with their Latin equivalents.
 * Characters not in the map are replaced with an empty string.
 * @param {string} str - The input string containing Cyrillic characters.
 * @returns {string} - The transliterated string with Latin characters.
 */
var replaceCyrillicWithLatin = function replaceCyrillicWithLatin() {
  var str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
  return str.replace(/[\u0400-\u04FF]/g, function (c) {
    var _CYRILLIC_TO_LATIN_MA;
    return (_CYRILLIC_TO_LATIN_MA = CYRILLIC_TO_LATIN_MAP[c]) !== null && _CYRILLIC_TO_LATIN_MA !== void 0 ? _CYRILLIC_TO_LATIN_MA : '';
  });
};

/*
  Array utility functions for SuperCreatives Checker
  Modern ES6+ syntax
*/

var _find = function _find(array, predicate) {
  for (var i = 0; i < array.length; i++) {
    if (predicate(array[i])) {
      return array[i];
    }
  }
  return null;
};
var _forEach = function _forEach(array, callback) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  array = array || [];
  for (var i = options.first || 0; i < (options.last || array.length); i++) {
    if (Object.prototype.hasOwnProperty.call(array, i)) {
      callback(array[i], i, array);
    }
  }
};
var _objectKeys = function _objectKeys(obj) {
  var keys = [];
  for (var key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
      keys.push(key);
    }
  }
  return keys;
};

/*
  Layer utility functions for SuperCreatives Checker
  Modern ES6+ syntax
*/

var _forEachLayer = function _forEachLayer(app) {
  var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {};
  var filterItem = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {
    return true;
  };
  var filterLayer = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {
    return true;
  };
  var filteredObjects = [];
  for (var i = 1; i <= app.project.numItems; i++) {
    var item = app.project.item(i);
    if (!filterItem(item)) continue;
    for (var j = 1; j <= item.numLayers; j++) {
      var layer = item.layer(j);
      if (!filterLayer(layer, item)) continue;
      filteredObjects.push({
        layer: layer,
        item: item
      });
    }
  }
  _forEach(filteredObjects, function (obj) {
    callback(obj.layer, obj.item);
  });
};
var isCompItem = function isCompItem(item) {
  return item instanceof CompItem;
};
var isTextLayer = function isTextLayer(layer) {
  return layer instanceof TextLayer;
};
var isEditableLayer = function isEditableLayer(layer) {
  return layer.name.indexOf('editable_') === 0;
};
var isEditableTextLayer = function isEditableTextLayer(layer) {
  return isTextLayer(layer) && isEditableLayer(layer) && !layer.property('Source Text').value.boxText;
};

/*
  Property utility functions for SuperCreatives Checker
  Modern ES6+ syntax
*/

var _copyPropertiesRecursive = function copyPropertiesRecursive(sourcePropGroup, targetPropGroup) {
  for (var i = 1; i <= sourcePropGroup.numProperties; i++) {
    var sourceProp = sourcePropGroup.property(i);
    var targetProp = targetPropGroup.property(sourceProp.matchName); // matchName is more robust than name

    if (!targetProp) {
      continue; // Property doesn't exist on target (e.g., Effect not yet added)
    }
    try {
      if (sourceProp.numProperties > 0) {
        // It's a group (e.g., "Transform" or "Text")
        _copyPropertiesRecursive(sourceProp, targetProp);
      } else if (sourceProp.canSetExpression && !sourceProp.isTimeVarying) {
        // Scalar or multidimensional property with single value
        targetProp.setValue(sourceProp.value);
      } else if (!sourceProp.isTimeVarying) {
        // Safe fallback for non-animated properties
        targetProp.setValue(sourceProp.value);
      }
      // Optional: copy expression if needed
      if (sourceProp.expressionEnabled) {
        targetProp.expression = sourceProp.expression;
      }
    } catch (err) {
      // Skip properties that throw errors (read-only, incompatible types, etc.)
      // $.writeln("Skipping: " + sourceProp.name + " — " + err.toString());
    }
  }
};
var alignNewLayerFromOriginalLayer = function alignNewLayerFromOriginalLayer(originalLayer, newLayer) {
  if (!originalLayer || !newLayer) return;
  var compTime = 0;

  // Get source rects
  var origBounds = originalLayer.sourceRectAtTime(compTime, false);
  var newBounds = newLayer.sourceRectAtTime(compTime, false);

  // Get anchor and position of original
  var origAnchor = originalLayer.property('Anchor Point').value;
  var origPos = originalLayer.property('Position').value;

  // Calculate visual top-left corner of original
  var origVisualTopLeft = [origPos[0] - origAnchor[0] + origBounds.left, origPos[1] - origAnchor[1] + origBounds.top];

  // Set new anchor to match new bounds top-left
  var newAnchor = [newBounds.left, newBounds.top];
  newLayer.property('Anchor Point').setValue(newAnchor);

  // Set position so top-left aligns visually
  newLayer.property('Position').setValue(origVisualTopLeft);
};

function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
var getInvalidLayers = function getInvalidLayers(comp) {
  var invalidLayers = [];
  for (var i = 1; i <= comp.numLayers; i++) {
    var layer = comp.layer(i);
    var hadCyrillic = containsCyrillic(layer.name);
    var unicodeIssue = containsInvalidUnicode(layer.name);
    var invalid = !isNameValid(layer.name);
    if (hadCyrillic || unicodeIssue || invalid) {
      invalidLayers.push({
        layer: layer,
        compName: comp.name,
        hadCyrillic: hadCyrillic,
        unicodeIssue: unicodeIssue
      });
    }
  }
  return invalidLayers;
};
var getInvalidComps = function getInvalidComps() {
  var invalidComps = [];
  for (var i = 1; i <= app.project.numItems; i++) {
    var item = app.project.item(i);
    if (item instanceof CompItem) {
      var hadCyrillic = containsCyrillic(item.name);
      var unicodeIssue = containsInvalidUnicode(item.name);
      var invalid = !isNameValid(item.name);
      if (hadCyrillic || unicodeIssue || invalid) {
        invalidComps.push({
          comp: item,
          hadCyrillic: hadCyrillic,
          unicodeIssue: unicodeIssue
        });
      }
    }
  }
  return invalidComps;
};
var getInvalidFootage = function getInvalidFootage() {
  var invalidFootage = [];
  for (var i = 1; i <= app.project.numItems; i++) {
    var item = app.project.item(i);
    if (item instanceof FootageItem && item.name) {
      var hadCyrillic = containsCyrillic(item.name);
      var unicodeIssue = containsInvalidUnicode(item.name);
      var invalid = !isNameValid(item.name);
      if (hadCyrillic || unicodeIssue || invalid) {
        invalidFootage.push({
          footage: item,
          hadCyrillic: hadCyrillic,
          unicodeIssue: unicodeIssue
        });
      }
    }
  }
  return invalidFootage;
};
var getActiveCompInvalidLayers = function getActiveCompInvalidLayers() {
  var invalidLayers = [];
  for (var i = 1; i <= app.project.numItems; i++) {
    var item = app.project.item(i);
    var _invalidLayers = getInvalidLayers(item);
    invalidLayers.push.apply(invalidLayers, _toConsumableArray(_invalidLayers));
  }
  return invalidLayers;
};

/*
  Font utility functions for SuperCreatives Checker
  Modern ES6+ syntax
*/

var findFont = function findFont(fontName) {
  var fontDirs = [new Folder(Folder.userData.fsName + '/../Fonts'), new Folder('/Library/Fonts'), new Folder('/System/Library/Fonts'), new Folder('~/Library/Fonts'), new Folder('C:/Windows/Fonts')];
  for (var i = 0; i < fontDirs.length; i++) {
    var dir = fontDirs[i];
    if (!dir.exists) continue;
    var files = dir.getFiles(function (f) {
      return f instanceof File && f.name.match(/\.(ttf|otf)$/i);
    });
    var matchedFile = files.find(function (f) {
      return f.name.toLowerCase().includes(fontName.toLowerCase().split(' ').join(''));
    });
    if (matchedFile) return matchedFile;
  }
  return null;
};

/*
  Main utils index file for SuperCreatives Checker
  Re-export all utilities from separate modules
  Modern ES6+ syntax
*/

var fixNames = function fixNames() {
  var results = {
    fixedLayers: [],
    fixedComps: [],
    fixedFootages: [],
    invalidLayers: [],
    invalidComps: [],
    invalidFootages: []
  };
  var invalidLayers = getActiveCompInvalidLayers();
  _forEach(invalidLayers, function (lyrInfo) {
    if (lyrInfo.hadCyrillic) {
      var newName = replaceCyrillicWithLatin(lyrInfo.layer.name);
      lyrInfo.layer.name = newName;
      results.fixedLayers.push(lyrInfo.layer);
    }
    if (!isNameValid(lyrInfo.layer.name)) {
      var cleanName = sanitizeInvalidName(lyrInfo.layer.name);
      lyrInfo.layer.name = cleanName;
      results.fixedLayers.push(lyrInfo.layer);
    }
  });
  var invalidComps = getInvalidComps();
  _forEach(invalidComps, function (compInfo) {
    if (compInfo.hadCyrillic) {
      var newCompName = replaceCyrillicWithLatin(compInfo.comp.name);
      compInfo.comp.name = newCompName;
      results.fixedComps.push(compInfo.comp);
    }
    if (!isNameValid(compInfo.comp.name)) {
      var cleanCompName = sanitizeInvalidName(compInfo.comp.name);
      compInfo.comp.name = cleanCompName;
      results.fixedComps.push(compInfo.comp);
    }
  });
  var invalidFootage = getInvalidFootage();
  _forEach(invalidFootage, function (ftgInfo) {
    if (ftgInfo.hadCyrillic) {
      var newName = replaceCyrillicWithLatin(ftgInfo.footage.name);
      ftgInfo.footage.name = newName;
      results.fixedFootages.push(ftgInfo.footage);
    }
    if (!isNameValid(ftgInfo.footage.name)) {
      var cleanName = sanitizeInvalidName(ftgInfo.footage.name);
      ftgInfo.footage.name = cleanName;
      results.fixedFootages.push(ftgInfo.footage);
    }
    if (ftgInfo.footage.file && ftgInfo.footage.file.exists) {
      var originalFile = ftgInfo.footage.file;
      var parentFolder = originalFile.parent;
      var cleanFileName = sanitizeInvalidName(originalFile.displayName);
      if (cleanFileName !== originalFile.displayName) {
        var cleanFile = new File(parentFolder.fsName + '/' + cleanFileName);
        try {
          if (originalFile.copy(cleanFile)) {
            ftgInfo.footage.replace(cleanFile);
            results.fixedFootages.push(ftgInfo.footage);
          } else {
            results.invalidFootages.push(ftgInfo.footage);
          }
        } catch (e) {
          results.invalidFootages.push(ftgInfo.footage);
        }
      }
    }
  });
  return results;
};

var findEditableLayers = function findEditableLayers() {
  var results = {
    editableLayers: []
  };
  _forEachLayer(app, function (layer) {
    results.editableLayers.push(layer);
  }, isCompItem, isEditableLayer);
  return results;
};

var fixEditableParagraphText = function fixEditableParagraphText() {
  var results = {
    fixedLayers: [],
    errorLayers: []
  };
  var replaceLayer = function replaceLayer(layer, item) {
    var bounds = layer.sourceRectAtTime(0, false);
    var layerName = layer.name;
    var boxWidth = bounds.width;
    var boxHeight = bounds.height;
    var newLayer = item.layers.addBoxText([boxWidth, boxHeight]);
    newLayer.moveBefore(layer);
    newLayer.name = layerName;
    _copyPropertiesRecursive(layer, newLayer);
    alignNewLayerFromOriginalLayer(layer, newLayer);
    layer.remove();
    return newLayer;
  };
  _forEachLayer(app, function (layer, item) {
    try {
      var newLayer = replaceLayer(layer, item);
      results.fixedLayers.push(newLayer);
    } catch (error) {
      results.errorLayers.push(layer);
    }
  }, isCompItem, isEditableTextLayer);
  return results;
};

var findEditableNotBoxLayers = function findEditableNotBoxLayers() {
  var results = {
    editableNotBoxLayer: []
  };
  _forEachLayer(app, function (layer) {
    results.editableNotBoxLayer.push(layer);
  }, isCompItem, isEditableTextLayer);
  return results;
};

var validateEditableImages = function validateEditableImages() {
  var rootComp = app.project.activeItem;
  var invalidLayers = [];
  _forEachLayer(app, function (layer) {
    invalidLayers.push(layer);
  }, function (item) {
    return isCompItem(item);
  }, function (layer, item) {
    return layer instanceof AVLayer && layer.source instanceof FootageItem && layer.source.mainSource instanceof FileSource && layer.source.mainSource.isStill && layer.name.indexOf('editable_') === 0 && item === rootComp;
  });
  return {
    invalidLayers: invalidLayers
  };
};

var SUPPORTED_FORMATS_IMAGES = ['.jpg', '.jpeg', '.png'];
var SUPPORTED_FORMATS = [].concat(SUPPORTED_FORMATS_IMAGES, ['.mp4',
// ".mp3", - supported, but there are problems with rendering
'.wav'
// ".mov", ".pdf" // supported but not recommended
]);

function isSupportedFormat(item) {
  var name = item.file.name.toLowerCase();
  for (var j = 0; j < SUPPORTED_FORMATS.length; j++) {
    var ext = SUPPORTED_FORMATS[j];
    if (name.indexOf(ext, name.length - ext.length) !== -1) {
      return true;
    }
  }
  return false;
}
var validateFootageFormats = function validateFootageFormats() {
  var results = {
    invalidFootage: []
  };
  for (var i = 1; i <= app.project.numItems; i++) {
    var item = app.project.item(i);
    if (item instanceof FootageItem && item.file !== null && item.file.exists) {
      var isValid = isSupportedFormat(item);
      if (!isValid) {
        results.invalidFootage.push(item);
      }
    }
  }
  return results;
};

var findUsedFonts = function findUsedFonts() {
  var results = {
    usedFonts: []
  };
  var fonts = {};
  _forEachLayer(app, function (layer) {
    var fontName = layer.property('Source Text').value.font;
    fonts[fontName] = true;
  }, isCompItem, isTextLayer);
  results.usedFonts = _objectKeys(fonts);
  return results;
};

var collectFonts = function collectFonts() {
  var results = {
    collectedFonts: [],
    missingFonts: []
  };
  var fonts = findUsedFonts().usedFonts;
  if (!fonts.length) return results;
  var projectFolder = app.project.file.parent;
  var fontsFolder = new Folder(projectFolder.fsName + '/Fonts');
  if (!fontsFolder.exists) fontsFolder.create();
  var existingFiles = fontsFolder.getFiles(function (f) {
    return f instanceof File && f.name.match(/\.(ttf|otf)$/i);
  });
  _forEach(fonts, function (fontName) {
    var matchedFile = findFont(fontName);
    if (matchedFile) {
      var targetFile = new File(fontsFolder.fsName + '/' + matchedFile.name);
      if (!targetFile.exists) {
        matchedFile.copy(targetFile);
      }
      results.collectedFonts.push(fontName);
    } else {
      var foundInFolder = false;
      foundInFolder = !!_find(existingFiles, function (f) {
        return f.name.toLowerCase().indexOf(fontName.toLowerCase().split(' ').join('')) !== -1;
      });
      if (!foundInFolder) {
        results.missingFonts.push(fontName);
      } else {
        results.collectedFonts.push(fontName);
      }
    }
  });
  return results;
};

var validateAndFixAll = function validateAndFixAll() {
  var allClear = true;
  var editableReport = [];
  var summary = [];
  var errors = [];
  var fixResult = fixNames();
  if (fixResult.fixedLayers.length > 0 || fixResult.fixedComps.length > 0 || fixResult.fixedFootages.length > 0) {
    summary.push('Names fixed: ' + (fixResult.fixedLayers.length ? fixResult.fixedLayers.length + ' layers, ' : '') + (fixResult.fixedComps.length ? fixResult.fixedComps.length + ' comps, ' : '') + (fixResult.fixedFootages.length ? fixResult.fixedFootages.length + ' footages' : ''));
  }
  if (fixResult.invalidFootages.length > 0) {
    errors.push('Errors fixing footages: ' + fixResult.invalidFootages.length + ' invalid footages');
    allClear = false;
  }

  // const paraResult = fixEditableParagraphText();
  // if (paraResult.errorLayers.length > 0) {
  //   errors.push('❌ Editable paragraph text issues: ' + paraResult.errorLayers.length + ' layers');
  //   allClear = false;
  // }
  // if (paraResult.fixedLayers.length > 0) {
  //   summary.push('Editable paragraph text fixed: ' + paraResult.fixedLayers.length + ' layers');
  // }

  var paraResult = findEditableNotBoxLayers();
  if (paraResult.editableNotBoxLayer.length > 0) {
    errors.push('❌ Not all editable text layer are type Paragraph: ' + paraResult.editableNotBoxLayer.length + ' layers');
    allClear = false;
  }
  var imgResult = validateEditableImages();
  if (imgResult.invalidLayers.length > 0) {
    errors.push('❌ Editable image layer issues: ' + imgResult.invalidLayers.length + ' layers');
    allClear = false;
  } else {
    summary.push('Editable images validated: no issues found');
  }
  var editResult = findEditableLayers();
  if (editResult.editableLayers && editResult.editableLayers.length > 0) {
    editableReport = [];
    for (var i = 0; i < editResult.editableLayers.length; i++) {
      editableReport.push('• ' + editResult.editableLayers[i].name + ' in comp: ' + editResult.editableLayers[i].containingComp.name);
    }
  }
  var footageResult = validateFootageFormats();
  if (footageResult.invalidFootage && footageResult.invalidFootage.length > 0) {
    errors.push('❌ Unsupported footage formats: ' + footageResult.invalidFootage.length + ' items');
    allClear = false;
  } else {
    summary.push('Footage formats checked: all supported');
  }
  var fontsResult = collectFonts();
  if (fontsResult.missingFonts && fontsResult.missingFonts.length > 0) {
    errors.push('❌ Font issues: ' + fontsResult.missingFonts.length + ' missing fonts');
    allClear = false;
  } else {
    summary.push('Fonts collected: no issues');
  }
  var msg = '';
  if (allClear) {
    msg = '✅ Project is ready for export!\n';
    if (editableReport.length > 0) {
      msg += '\nEditable layers:\n' + editableReport.join('\n');
    } else {
      msg += '\nNo editable layers found.';
    }
    if (summary.length > 0) {
      msg += '\n\n' + summary.join('\n\n');
    }
  } else {
    msg = '⚠️ Issues found:\n\n' + errors.join('\n\n');
    if (editableReport.length > 0) {
      msg += '\n\nEditable layers:\n' + editableReport.join('\n');
    }
    if (summary.length > 0) {
      msg += '\n\n' + summary.join('\n\n');
    }
  }
  return msg;
};

var alertMessage = function alertMessage(type, actionType, message) {
  var alertMessage = '';
  if (type === 'error') {
    alertMessage += '❌ ';
  } else if (type === 'success') {
    alertMessage += '✅ ';
  }
  alertMessage += actionType + ' \n';
  alertMessage += message || '';
  alert(alertMessage);
};

(function (globalThisObj) {
  /* ========================================================================
  Copyright © Oleksii Bondarenko (oleksii.austria@gmail.com)
  All rights reserved.
  This ScriptUI panel script is developed for Adobe After Effects.
  It provides two actions: one to validate layer and composition names,
  and another to fix Cyrillic characters by replacing or removing them.
  Unauthorized copying, modification, or redistribution of this script
  is strictly prohibited. For reuse, licensing, or collaboration,
  please contact the author via email.
  ======================================================================= */

  var createPanel = function createPanel(thisObj) {
    var myPanel = thisObj instanceof Panel ? thisObj : new Window('palette', 'Supercreatives <> Checker', undefined, {
      resizeable: true
    });
    myPanel.orientation = 'column';
    myPanel.alignChildren = ['fill', 'top'];
    var headerGroup = myPanel.add('group');
    headerGroup.orientation = 'column';
    headerGroup.alignment = ['fill', 'top'];
    headerGroup.add('statictext', undefined, 'SuperCreatives <> Checker');
    headerGroup.add('statictext', undefined, 'Validates AE projects to ensure templates will work well.');
    headerGroup.add('statictext', undefined, 'Make sure all needed layers have prefix ‘editable_’');
    var createButton = function createButton(label, onClick) {
      var panel = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : myPanel;
      var btn = panel.add('button', undefined, label);
      btn.onClick = onClick;
      return btn;
    };
    var layersToMessage = function layersToMessage() {
      var layers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
      var msg = '';
      layers.forEach(function (layer) {
        var _layer$containingComp;
        msg += "- Layer ".concat(layer.name);
        msg += layer.containingComp ? " in Comp: ".concat((_layer$containingComp = layer.containingComp) === null || _layer$containingComp === void 0 ? void 0 : _layer$containingComp.name) : '';
        msg += '\n';
      });
      return msg;
    };
    var validateFixBtn = createButton('✔️ Validate & Fix Names', function () {
      try {
        var res = fixNames();
        var msg = '';
        if (res.fixedLayers.length + res.fixedComps.length + res.fixedFootages.length) {
          msg += 'Fixed:\n';
          if (res.fixedLayers.length) {
            msg += '• Layers:\n';
            msg += layersToMessage(res.fixedLayers);
          }
          if (res.fixedComps.length) {
            msg += '• Comps:\n';
            msg += layersToMessage(res.fixedComps);
          }
          if (res.fixedFootages.length) {
            msg += '• Footages:\n';
            msg += layersToMessage(res.fixedFootages);
          }
        }
        if (res.invalidLayers.length + res.invalidComps.length + res.invalidFootages.length) {
          msg += 'Still invalid:\n';
          if (res.invalidLayers.length) {
            msg += '• Layers:\n';
            msg += layersToMessage(res.invalidLayers);
          }
          if (res.invalidComps.length) {
            msg += '• Comps:\n';
            msg += layersToMessage(res.invalidComps);
          }
          if (res.invalidFootages.length) {
            msg += '• Footages:\n';
            msg += layersToMessage(res.invalidFootages);
          }
        }
        alertMessage('none', 'Validate & Fix Names', msg || 'All good!');
      } catch (e) {
        alertMessage('error', 'Error in Validate & Fix Names:\n' + e.toString() + '\n\nStack trace:\n' + $.stack);
      }
    });
    var reportEditableBtn = createButton('📄 Report Editable Layers', function () {
      try {
        var res = findEditableLayers();
        var msg = '';
        if (res.editableLayers && res.editableLayers.length > 0) {
          msg += 'Editable layers:\n';
          msg += layersToMessage(res.editableLayers);
        } else {
          msg += 'No editable layers found. \n';
        }
        alertMessage('none', 'Report Editable Layers', msg);
      } catch (e) {
        alertMessage('error', 'Error in Report Editable Layers: ' + e.toString());
      }
    });
    var validateEditableImagesBtn = createButton('🖼 Validate Editable Image Layers', function () {
      try {
        var res = validateEditableImages();
        var msg = '';
        if (res.invalidLayers && res.invalidLayers.length > 0) {
          msg += 'With issues:\n';
          msg += layersToMessage(res.invalidLayers);
          msg += 'Please fix them manually. Make sure all editable images are inside pre-comps and not inside root comp. \n';
        }
        alertMessage('none', 'Validate Editable Images', msg || 'All good!');
      } catch (e) {
        alertMessage('error', 'Error in Validate Editable Images: ' + e.toString());
      }
    });

    // const fixParagraphBtn = createButton(
    //   '🅰️ Fix Editable Paragraph Text',
    //   () => {
    //     try {
    //       const res = fixEditableParagraphText();
    //       let msg = '';
    //       if (res.errorLayers && res.errorLayers.length > 0) {
    //         msg += 'Not fixed:\n';
    //         msg += layersToMessage(res.errorLayers);
    //         msg +=
    //           'Please fix them manually. Make sure all editable text are Paragraph text layers. \n';
    //       }

    //       if (res.fixedLayers && res.fixedLayers.length > 0) {
    //         msg += 'Fixed:\n';
    //         msg += layersToMessage(res.fixedLayers);
    //       }

    //       alertMessage(
    //         'none',
    //         'Fix Editable Paragraph Text',
    //         msg || 'All good!'
    //       );
    //     } catch (e) {
    //       alertMessage(
    //         'error',
    //         'Error in Fix Editable Paragraph Text: ' + e.toString()
    //       );
    //     }
    //   }
    // );

    var fixParagraphBtn = createButton('🅰️ Find Editable Not Paragraph Text', function () {
      try {
        var res = findEditableNotBoxLayers();
        var msg = '';
        if (res.editableNotBoxLayer && res.editableNotBoxLayer.length > 0) {
          msg += 'Not pragraph text layers:\n';
          msg += layersToMessage(res.editableNotBoxLayer);
          msg += "Convert those layers to Paragraph so it's scale properly with bigger text content. \n";
        }
        alertMessage('none', 'Find Editable Not Paragraph Text', msg || 'All good!');
      } catch (e) {
        alertMessage('error', 'Error in Find Editable Not Paragraph Text: ' + e.toString());
      }
    });
    var checkFormatsBtn = createButton('🎞 Check Footage Formats', function () {
      try {
        var res = validateFootageFormats();
        var msg = '';
        if (res.invalidFootage && res.invalidFootage.length > 0) {
          msg += 'Unsupported footage formats:\n';
          res.invalidFootage.forEach(function (footage) {
            msg += "\u2022 ".concat(footage.name, "\n");
          });
          msg += 'Please fix them manually. We support only ' + SUPPORTED_FORMATS.join(', ') + ' formats.\n';
        }
        alertMessage('none', 'Check Footage Formats', msg || 'All good!');
      } catch (e) {
        alertMessage('error', 'Error in Check Footage Formats: ' + e.toString());
      }
    });
    var fontRow = myPanel.add('group');
    fontRow.orientation = 'row';
    var reportUsedFontsBtn = createButton('🔤 Report Used Fonts', function () {
      try {
        var res = findUsedFonts();
        var msg = '';
        if (res.usedFonts && res.usedFonts.length > 0) {
          msg += 'Used fonts:\n';
          res.usedFonts.forEach(function (font) {
            msg += "\u2022 ".concat(font, "\n");
          });
        }
        alertMessage('none', 'Report Used Fonts', msg || 'No fonts found!');
      } catch (e) {
        alertMessage('error', 'Error in Report Used Fonts: ' + e.toString());
      }
    }, fontRow);
    var collectFontsBtn = createButton('📦 Collect Fonts', function () {
      try {
        var res = collectFonts();
        var msg = '';
        if (res.missingFonts.length === 0) {
          return alertMessage('none', 'Collect Fonts', 'All fonts collected!');
        }
        if (res.missingFonts && res.missingFonts.length > 0) {
          msg += 'Missing fonts:\n';
          res.missingFonts.forEach(function (font) {
            msg += "\u2022 ".concat(font, "\n");
          });
          msg += 'Please add them manually to Fonts folder. We support only .ttf and .otf formats. \n';
        }
        if (res.collectedFonts && res.collectedFonts.length > 0) {
          msg += 'Collected fonts:\n';
          res.collectedFonts.forEach(function (font) {
            msg += "\u2022 ".concat(font, "\n");
          });
        }
        alertMessage('none', 'Collect Fonts', msg || 'All good!');
      } catch (e) {
        alertMessage('error', 'Error in Collect Fonts: ' + e.toString());
      }
    }, fontRow);
    var validateFixAllBtn = createButton('🔄 One-Click Validate & Fix All ✅', function () {
      try {
        var res = validateAndFixAll();
        alertMessage('none', 'Validate & Fix All', res);
      } catch (e) {
        alertMessage('error', 'Error in Validate & Fix (All): ' + e.toString());
      }
    });
    myPanel.add('statictext', undefined, 'Built by Supercreatives').justification = 'center';
    myPanel.layout.layout(true);

    // Simulate percentage-based width
    var resizeButtons = function resizeButtons() {
      var fullWidth = myPanel.size.width;
      var padding = 20; // optional internal padding
      var buttonWidth = fullWidth * 0.9 - padding;
      var allButtons = [validateFixBtn, reportEditableBtn, validateEditableImagesBtn, fixParagraphBtn, checkFormatsBtn, validateFixAllBtn, reportUsedFontsBtn, collectFontsBtn];
      for (var i = 0; i < allButtons.length; i++) {
        if (allButtons[i]) allButtons[i].preferredSize.width = buttonWidth;
      }
    };
    myPanel.onResize = resizeButtons;
    resizeButtons();
    return myPanel;
  };
  createPanel(globalThisObj);
})(this);

[vladavoX]

[vladavoX]

• we got an error for a file that has :, we can add this check also, to have normal characters in files

[vladavoX]

check if comps or layers have special characters in their names