@ccslabs/xtend 0.1.0-rc.1

package/catalog/enterprise-icon-control-audit.js

@@ -0,0 +1,258 @@
+const fs = require('fs');
+const path = require('path');
+
+const ENTERPRISE_ICON_CONTROL_AUDIT_SCHEMA = 'xtend.enterprise.icon-control-audit.v1';
+const ENTERPRISE_ICON_CONTROL_AUDIT_FINDING_SCHEMA = 'xtend.enterprise.icon-control-audit-finding.v1';
+const ENTERPRISE_ICON_CONTROL_AUDIT_REPORT_SCHEMA = 'xtend.enterprise.icon-control-audit-report.v1';
+const ENTERPRISE_ICON_CONTROL_AUDIT_WORKPACKAGE = 'ECH-WP-04';
+const ENTERPRISE_ICON_CONTROL_AUDIT_LOCAL_GATE = 'node scripts/run_xtend_tests.js enterprise-icon-control-audit --json';
+
+const PRODUCTION_SCAN_PATHS = Object.freeze([
+  'components',
+  'src/components',
+  'xtend.js',
+  'xtend-dev.js',
+  'xtend-loader.js'
+]);
+
+const IGNORED_FILES = Object.freeze([
+  'components/prism.js'
+]);
+
+const SCAN_EXTENSIONS = Object.freeze(['.js', '.ts']);
+
+const REQUIRED_CORE_ICONS = Object.freeze([
+  'close',
+  'menu',
+  'chevron-left',
+  'chevron-right',
+  'chevron-up',
+  'chevron-down',
+  'success',
+  'warning',
+  'error',
+  'info',
+  'pin',
+  'minus',
+  'maximize'
+]);
+
+const CONTROL_KEYWORDS = Object.freeze([
+  'close',
+  'dismiss',
+  'menu',
+  'collapse',
+  'expand',
+  'minimize',
+  'maximize',
+  'pin',
+  'previous',
+  'next',
+  'scroll',
+  'copy'
+]);
+
+const TEXT_GLYPH_ENTITIES = Object.freeze([
+  '×',
+  '×',
+  '×',
+  '×',
+  '<',
+  '>',
+  '☰',
+  '✓',
+  '⚠'
+]);
+
+const TEXT_GLYPH_LITERALS = Object.freeze([
+  'x',
+  'X',
+  '_',
+  '[]',
+  '-',
+  '+',
+  'P',
+  '\\u00d7',
+  '\\u2630',
+  '\\u2713',
+  '\\u26a0',
+  '\\u2191',
+  '\\u2192',
+  '\\u2193',
+  '\\u2190'
+]);
+
+function normalizePath(value) {
+  return String(value || '').replace(/\\/g, '/');
+}
+
+function resolveRootDir(rootDir) {
+  return rootDir || path.resolve(__dirname, '..');
+}
+
+function walkFiles(rootDir, relativePath, output = []) {
+  const normalized = normalizePath(relativePath);
+  if (IGNORED_FILES.includes(normalized)) return output;
+  const absolutePath = path.join(rootDir, relativePath);
+  if (!fs.existsSync(absolutePath)) return output;
+  const stat = fs.statSync(absolutePath);
+  if (stat.isFile()) {
+    if (SCAN_EXTENSIONS.includes(path.extname(absolutePath))) output.push(normalized);
+    return output;
+  }
+  fs.readdirSync(absolutePath).forEach((entry) => {
+    walkFiles(rootDir, path.join(relativePath, entry), output);
+  });
+  return output;
+}
+
+function lineNumberAt(text, index) {
+  return text.slice(0, index).split(/\r?\n/u).length;
+}
+
+function stripTags(value) {
+  return String(value || '')
+    .replace(/<[^>]+>/gu, '')
+    .replace(/\$\{[^}]+\}/gu, '')
+    .trim();
+}
+
+function isTextGlyphControlContent(value) {
+  const text = stripTags(value);
+  const lowered = text.toLowerCase();
+  if (!text) return false;
+  if (TEXT_GLYPH_ENTITIES.includes(lowered)) return true;
+  return TEXT_GLYPH_LITERALS.some((glyph) => text === glyph || text === JSON.parse(`"${glyph}"`));
+}
+
+function isControlButton(attrs, body) {
+  const haystack = `${attrs || ''} ${body || ''}`.toLowerCase();
+  return CONTROL_KEYWORDS.some((keyword) => new RegExp(`(?:^|[^a-z0-9-])${keyword}(?:$|[^a-z0-9-])`, 'u').test(haystack)) ||
+    /class=["'][^"']*(close|copy|burger|trigger)[^"']*["']/u.test(haystack) ||
+    /data-action=["'][^"']*(close|pin|collapse|minimize|maximize)[^"']*["']/u.test(haystack);
+}
+
+function hasAccessibleName(attrs) {
+  return /\s(aria-label|aria-labelledby|title)=["'][^"']+["']/u.test(attrs || '');
+}
+
+function hasControlPart(attrs) {
+  return /part=["'][^"']*\bcontrol\b[^"']*["']/u.test(attrs || '');
+}
+
+function hasIconGraphic(body) {
+  return /<\s*(svg|x-icon)\b/iu.test(body || '') ||
+    /part=["'][^"']*\bicon\b[^"']*["']/iu.test(body || '') ||
+    /xtendLegacyControlIcon/u.test(body || '');
+}
+
+function hasIconPart(body) {
+  return /part=["'][^"']*\bicon\b[^"']*["']/iu.test(body || '') ||
+    /xtendLegacyControlIcon/u.test(body || '');
+}
+
+function addFinding(findings, category, file, line, message, excerpt) {
+  findings.push({
+    schema: ENTERPRISE_ICON_CONTROL_AUDIT_FINDING_SCHEMA,
+    category,
+    file,
+    line,
+    message,
+    excerpt: String(excerpt || '').trim().slice(0, 220),
+    blocking: true
+  });
+}
+
+function scanFile(rootDir, relativePath) {
+  const file = normalizePath(relativePath);
+  const text = fs.readFileSync(path.join(rootDir, file), 'utf8');
+  const findings = [];
+  const buttonPattern = /<button\b([^>]*)>([\s\S]*?)<\/button>/giu;
+  let match;
+
+  while ((match = buttonPattern.exec(text))) {
+    const attrs = match[1] || '';
+    const body = match[2] || '';
+    const block = match[0];
+    const line = lineNumberAt(text, match.index);
+    const control = isControlButton(attrs, body);
+
+    if (isTextGlyphControlContent(body)) {
+      addFinding(findings, 'control.text-glyph', file, line, 'visible text glyph used as a control graphic', block);
+    }
+    if (control && hasIconGraphic(body) && !hasAccessibleName(attrs)) {
+      addFinding(findings, 'control.missing-accessible-name', file, line, 'icon control is missing an accessible name', block);
+    }
+    if (control && hasIconGraphic(body) && !hasControlPart(attrs)) {
+      addFinding(findings, 'control.missing-control-part', file, line, 'icon control button must expose a control CSS part', block);
+    }
+    if (control && hasIconGraphic(body) && !hasIconPart(body)) {
+      addFinding(findings, 'control.missing-icon-part', file, line, 'icon control graphic must expose an icon CSS part', block);
+    }
+  }
+
+  return findings;
+}
+
+function createEnterpriseIconControlAuditReport(options = {}) {
+  const rootDir = resolveRootDir(options.rootDir);
+  const files = (options.files && options.files.length ? options.files : PRODUCTION_SCAN_PATHS.flatMap((entry) => walkFiles(rootDir, entry)))
+    .map(normalizePath)
+    .filter((file) => !IGNORED_FILES.includes(file));
+  const findings = files.flatMap((file) => scanFile(rootDir, file));
+  const summary = findings.reduce((result, finding) => {
+    result.total += 1;
+    result.byCategory[finding.category] = (result.byCategory[finding.category] || 0) + 1;
+    return result;
+  }, { total: 0, byCategory: {} });
+
+  return {
+    schema: ENTERPRISE_ICON_CONTROL_AUDIT_SCHEMA,
+    reportSchema: ENTERPRISE_ICON_CONTROL_AUDIT_REPORT_SCHEMA,
+    findingSchema: ENTERPRISE_ICON_CONTROL_AUDIT_FINDING_SCHEMA,
+    workpackage: ENTERPRISE_ICON_CONTROL_AUDIT_WORKPACKAGE,
+    localGate: ENTERPRISE_ICON_CONTROL_AUDIT_LOCAL_GATE,
+    scanPaths: PRODUCTION_SCAN_PATHS.slice(),
+    ignoredFiles: IGNORED_FILES.slice(),
+    requiredCoreIcons: REQUIRED_CORE_ICONS.slice(),
+    files,
+    findings,
+    summary,
+    ok: findings.length === 0
+  };
+}
+
+function validateEnterpriseIconControlAuditReport(report = {}) {
+  const errors = [];
+  if (report.schema !== ENTERPRISE_ICON_CONTROL_AUDIT_SCHEMA) errors.push(`schema must be ${ENTERPRISE_ICON_CONTROL_AUDIT_SCHEMA}`);
+  if (report.reportSchema !== ENTERPRISE_ICON_CONTROL_AUDIT_REPORT_SCHEMA) errors.push(`reportSchema must be ${ENTERPRISE_ICON_CONTROL_AUDIT_REPORT_SCHEMA}`);
+  if (report.findingSchema !== ENTERPRISE_ICON_CONTROL_AUDIT_FINDING_SCHEMA) errors.push(`findingSchema must be ${ENTERPRISE_ICON_CONTROL_AUDIT_FINDING_SCHEMA}`);
+  if (report.workpackage !== ENTERPRISE_ICON_CONTROL_AUDIT_WORKPACKAGE) errors.push(`workpackage must be ${ENTERPRISE_ICON_CONTROL_AUDIT_WORKPACKAGE}`);
+  if (!Array.isArray(report.requiredCoreIcons) || !REQUIRED_CORE_ICONS.every((name) => report.requiredCoreIcons.includes(name))) errors.push('requiredCoreIcons must include every ECH-WP-04 core icon');
+  if (!report.summary || typeof report.summary.total !== 'number') errors.push('summary.total must be numeric');
+  if (!Array.isArray(report.findings)) errors.push('findings must be an array');
+  if (report.ok !== (Array.isArray(report.findings) && report.findings.length === 0)) errors.push('ok must reflect finding count');
+  return {
+    schema: ENTERPRISE_ICON_CONTROL_AUDIT_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+module.exports = {
+  CONTROL_KEYWORDS,
+  ENTERPRISE_ICON_CONTROL_AUDIT_FINDING_SCHEMA,
+  ENTERPRISE_ICON_CONTROL_AUDIT_LOCAL_GATE,
+  ENTERPRISE_ICON_CONTROL_AUDIT_REPORT_SCHEMA,
+  ENTERPRISE_ICON_CONTROL_AUDIT_SCHEMA,
+  ENTERPRISE_ICON_CONTROL_AUDIT_WORKPACKAGE,
+  IGNORED_FILES,
+  PRODUCTION_SCAN_PATHS,
+  REQUIRED_CORE_ICONS,
+  SCAN_EXTENSIONS,
+  TEXT_GLYPH_ENTITIES,
+  TEXT_GLYPH_LITERALS,
+  createEnterpriseIconControlAuditReport,
+  isTextGlyphControlContent,
+  validateEnterpriseIconControlAuditReport
+};

package/catalog/enterprise-layout-display-media-tokenization.d.ts

@@ -0,0 +1,20 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogOptions,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+export declare const ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_FINDING_SCHEMA: string;
+export declare const ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_LOCAL_GATE: string;
+export declare const ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_REPORT_SCHEMA: string;
+export declare const ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_SCHEMA: string;
+export declare const ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_WORKPACKAGE: string;
+export declare const LAYOUT_DISPLAY_MEDIA_TARGETS: readonly XtendCatalogRecord[];
+export declare const REQUIRED_DOC_MARKERS: readonly XtendCatalogConstant[];
+export declare const REQUIRED_FIXTURE_MARKERS: readonly XtendCatalogConstant[];
+export declare const REQUIRED_LAYOUT_TOKENS: readonly XtendCatalogConstant[];
+export declare const REQUIRED_SOURCE_MARKERS: readonly XtendCatalogConstant[];
+export declare const TEXT_GLYPH_CONTROL_PATTERNS: readonly XtendCatalogConstant[];
+export declare function createEnterpriseLayoutDisplayMediaTokenizationReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateEnterpriseLayoutDisplayMediaTokenizationReport(report?: unknown): XtendCatalogReport;

package/catalog/enterprise-layout-display-media-tokenization.js

@@ -0,0 +1,237 @@
+const fs = require('fs');
+const path = require('path');
+
+const ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_SCHEMA = 'xtend.enterprise.layout-display-media-tokenization.v1';
+const ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_FINDING_SCHEMA = 'xtend.enterprise.layout-display-media-tokenization-finding.v1';
+const ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_REPORT_SCHEMA = 'xtend.enterprise.layout-display-media-tokenization-report.v1';
+const ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_WORKPACKAGE = 'ECH-WP-07';
+const ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_LOCAL_GATE = 'node scripts/run_xtend_tests.js enterprise-layout-display-media-tokenization --json';
+
+const REQUIRED_LAYOUT_TOKENS = Object.freeze([
+  '--xtend-layout-surface',
+  '--xtend-layout-text',
+  '--xtend-layout-border-color',
+  '--xtend-layout-radius',
+  '--xtend-layout-elevation',
+  '--xtend-layout-spacing',
+  '--xtend-layout-gap',
+  '--xtend-layout-font-family',
+  '--xtend-layout-font-size',
+  '--xtend-layout-media-radius',
+  '--xtend-layout-focus-ring',
+  '--xtend-layout-grid-min',
+  '--xtend-layout-content-max'
+]);
+
+const REQUIRED_DOC_MARKERS = Object.freeze([
+  'ECH-WP-07',
+  'Token-Tabelle',
+  'signatureDesign',
+  'Fremdtheme'
+]);
+
+const REQUIRED_SOURCE_MARKERS = Object.freeze([
+  'signatureDesign',
+  'overflow-wrap: anywhere',
+  'prefers-reduced-motion',
+  'forced-colors'
+]);
+
+const REQUIRED_FIXTURE_MARKERS = Object.freeze([
+  'data-xtend-layout-theme="enterprise-foreign"',
+  '--xtend-layout-surface',
+  '--xtend-layout-text',
+  '--xtend-layout-radius',
+  '--xtend-layout-font-family'
+]);
+
+const TEXT_GLYPH_CONTROL_PATTERNS = Object.freeze([
+  'textContent = "▼"',
+  'textContent = "▶"',
+  '×',
+  '>x</button>',
+  '>X</button>'
+]);
+
+const LAYOUT_DISPLAY_MEDIA_TARGETS = Object.freeze([
+  {
+    tag: 'x-header',
+    file: 'components/xheader.js',
+    docs: 'docs/components/xheader.md',
+    fixture: 'tests/components/fixtures/xheader.component.html',
+    signatureRole: 'enterprise-app-shell'
+  },
+  {
+    tag: 'x-footer',
+    file: 'components/xfooter.js',
+    docs: 'docs/components/xfooter.md',
+    fixture: 'tests/components/fixtures/xfooter.component.html',
+    signatureRole: 'enterprise-footer'
+  },
+  {
+    tag: 'x-hero',
+    file: 'components/xhero.js',
+    docs: 'docs/components/xhero.md',
+    fixture: 'tests/components/fixtures/xhero.component.html',
+    signatureRole: 'editorial-hero'
+  },
+  {
+    tag: 'x-section',
+    file: 'components/xsection.js',
+    docs: 'docs/components/xsection.md',
+    fixture: 'tests/components/fixtures/xsection.component.html',
+    signatureRole: 'content-section'
+  },
+  {
+    tag: 'x-cards',
+    file: 'components/xcards.js',
+    docs: 'docs/components/xcards.md',
+    fixture: 'tests/components/fixtures/xcards.component.html',
+    signatureRole: 'card-grid'
+  },
+  {
+    tag: 'x-masonry',
+    file: 'components/xmasonry.js',
+    docs: 'docs/components/xmasonry.md',
+    fixture: 'tests/components/fixtures/xmasonry.component.html',
+    signatureRole: 'masonry-grid'
+  },
+  {
+    tag: 'x-code',
+    file: 'components/xcode.js',
+    docs: 'docs/components/xcode.md',
+    fixture: 'tests/components/fixtures/xcode.component.html',
+    signatureRole: 'code-surface'
+  }
+]);
+
+function resolveRootDir(rootDir) {
+  return rootDir || path.resolve(__dirname, '..');
+}
+
+function readFile(rootDir, relativePath) {
+  return fs.readFileSync(path.join(rootDir, relativePath), 'utf8');
+}
+
+function addFinding(findings, target, category, message, pattern, surface) {
+  findings.push({
+    schema: ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_FINDING_SCHEMA,
+    category,
+    tag: target.tag,
+    file: surface || target.file,
+    message,
+    pattern,
+    blocking: true
+  });
+}
+
+function inspectTarget(rootDir, target) {
+  const source = readFile(rootDir, target.file);
+  const docs = readFile(rootDir, target.docs);
+  const fixture = readFile(rootDir, target.fixture);
+  const findings = [];
+
+  REQUIRED_LAYOUT_TOKENS.forEach((token) => {
+    if (!source.includes(token)) {
+      addFinding(findings, target, 'layout.token.source-missing', `${target.tag} source must consume ${token}`, token);
+    }
+    if (!docs.includes(token)) {
+      addFinding(findings, target, 'layout.token.docs-missing', `${target.tag} docs must document ${token}`, token, target.docs);
+    }
+  });
+
+  REQUIRED_SOURCE_MARKERS.forEach((marker) => {
+    if (!source.includes(marker)) {
+      addFinding(findings, target, 'layout.source-marker.missing', `${target.tag} source must include ${marker}`, marker);
+    }
+  });
+
+  REQUIRED_DOC_MARKERS.forEach((marker) => {
+    if (!docs.includes(marker)) {
+      addFinding(findings, target, 'layout.docs-marker.missing', `${target.tag} docs must include ${marker}`, marker, target.docs);
+    }
+  });
+
+  REQUIRED_FIXTURE_MARKERS.forEach((marker) => {
+    if (!fixture.includes(marker)) {
+      addFinding(findings, target, 'layout.fixture-theme.missing', `${target.tag} fixture must show a foreign enterprise theme marker ${marker}`, marker, target.fixture);
+    }
+  });
+
+  TEXT_GLYPH_CONTROL_PATTERNS.forEach((pattern) => {
+    if (source.includes(pattern)) {
+      addFinding(findings, target, 'layout.control.text-glyph', `${target.tag} must not use visible text glyphs as controls`, pattern);
+    }
+  });
+
+  return {
+    tag: target.tag,
+    file: target.file,
+    docs: target.docs,
+    fixture: target.fixture,
+    signatureRole: target.signatureRole,
+    tokenCount: REQUIRED_LAYOUT_TOKENS.length,
+    findings
+  };
+}
+
+function createEnterpriseLayoutDisplayMediaTokenizationReport(options = {}) {
+  const rootDir = resolveRootDir(options.rootDir);
+  const targets = LAYOUT_DISPLAY_MEDIA_TARGETS.map((target) => inspectTarget(rootDir, target));
+  const findings = targets.flatMap((target) => target.findings);
+  const summary = findings.reduce((result, finding) => {
+    result.total += 1;
+    result.byCategory[finding.category] = (result.byCategory[finding.category] || 0) + 1;
+    return result;
+  }, { total: 0, byCategory: {} });
+
+  return {
+    schema: ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_SCHEMA,
+    reportSchema: ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_REPORT_SCHEMA,
+    findingSchema: ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_FINDING_SCHEMA,
+    workpackage: ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_WORKPACKAGE,
+    localGate: ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_LOCAL_GATE,
+    requiredTokens: REQUIRED_LAYOUT_TOKENS.slice(),
+    requiredDocMarkers: REQUIRED_DOC_MARKERS.slice(),
+    requiredFixtureMarkers: REQUIRED_FIXTURE_MARKERS.slice(),
+    targets,
+    findings,
+    summary,
+    ok: findings.length === 0
+  };
+}
+
+function validateEnterpriseLayoutDisplayMediaTokenizationReport(report = {}) {
+  const errors = [];
+  if (report.schema !== ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_SCHEMA) errors.push(`schema must be ${ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_SCHEMA}`);
+  if (report.reportSchema !== ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_REPORT_SCHEMA) errors.push(`reportSchema must be ${ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_REPORT_SCHEMA}`);
+  if (report.findingSchema !== ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_FINDING_SCHEMA) errors.push(`findingSchema must be ${ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_FINDING_SCHEMA}`);
+  if (report.workpackage !== ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_WORKPACKAGE) errors.push(`workpackage must be ${ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_WORKPACKAGE}`);
+  if (report.localGate !== ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_LOCAL_GATE) errors.push('invalid local gate');
+  if (!Array.isArray(report.requiredTokens) || !REQUIRED_LAYOUT_TOKENS.every((token) => report.requiredTokens.includes(token))) errors.push('requiredTokens must include every layout token');
+  if (!Array.isArray(report.targets) || report.targets.length !== LAYOUT_DISPLAY_MEDIA_TARGETS.length) errors.push('targets must cover every WP-07 target');
+  if (!Array.isArray(report.findings)) errors.push('findings must be an array');
+  if (!report.summary || typeof report.summary.total !== 'number') errors.push('summary.total must be numeric');
+  if (report.ok !== (Array.isArray(report.findings) && report.findings.length === 0)) errors.push('ok must reflect finding count');
+  return {
+    schema: ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+module.exports = {
+  ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_FINDING_SCHEMA,
+  ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_LOCAL_GATE,
+  ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_REPORT_SCHEMA,
+  ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_SCHEMA,
+  ENTERPRISE_LAYOUT_DISPLAY_MEDIA_TOKENIZATION_WORKPACKAGE,
+  LAYOUT_DISPLAY_MEDIA_TARGETS,
+  REQUIRED_DOC_MARKERS,
+  REQUIRED_FIXTURE_MARKERS,
+  REQUIRED_LAYOUT_TOKENS,
+  REQUIRED_SOURCE_MARKERS,
+  TEXT_GLYPH_CONTROL_PATTERNS,
+  createEnterpriseLayoutDisplayMediaTokenizationReport,
+  validateEnterpriseLayoutDisplayMediaTokenizationReport
+};

package/catalog/enterprise-navigation-routing-state-hardening.d.ts

@@ -0,0 +1,20 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogOptions,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+export declare const ENTERPRISE_NAVIGATION_ROUTING_STATE_HARDENING_FINDING_SCHEMA: string;
+export declare const ENTERPRISE_NAVIGATION_ROUTING_STATE_HARDENING_LOCAL_GATE: string;
+export declare const ENTERPRISE_NAVIGATION_ROUTING_STATE_HARDENING_REPORT_SCHEMA: string;
+export declare const ENTERPRISE_NAVIGATION_ROUTING_STATE_HARDENING_SCHEMA: string;
+export declare const ENTERPRISE_NAVIGATION_ROUTING_STATE_HARDENING_WORKPACKAGE: string;
+export declare const NAVIGATION_ROUTING_STATE_TARGETS: readonly XtendCatalogRecord[];
+export declare const REQUIRED_DOC_MARKERS: readonly XtendCatalogConstant[];
+export declare const REQUIRED_FIXTURE_MARKERS: readonly XtendCatalogConstant[];
+export declare const REQUIRED_NAVIGATION_TOKENS: readonly XtendCatalogConstant[];
+export declare const REQUIRED_SOURCE_MARKERS: readonly XtendCatalogConstant[];
+export declare const TEXT_GLYPH_CONTROL_PATTERNS: readonly XtendCatalogConstant[];
+export declare function createEnterpriseNavigationRoutingStateHardeningReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateEnterpriseNavigationRoutingStateHardeningReport(report?: unknown): XtendCatalogReport;