;
if (typeof sku === 'string' && Array.isArray(skus)) {
return renderInputError('LicenseBadge: pass either `sku` or `skus`, not both.');
}
if (skuList.length === 0) {
return renderInputError('LicenseBadge: `sku` or `skus` is required.');
}
if (hasFetchError) return renderBanner(skuList);
if (!data) return renderLoading();
return renderBanner(skuList);
};
export const YamlTable = ({children, data: propData, content}) => {
const KV_RE = /^([A-Za-z][A-Za-z0-9_()/#\s-]+?):\s*(.+)$/;
const INLINE_MD_RE = /(\[([^\]]+)\]\(([^)]+)\))|(`([^`]+)`)|(\*\*([^*]+)\*\*)|(\*([^*]+)\*)/g;
const YES_RE = /^-yes-$/i;
const NO_RE = /^-no-$/i;
const LIMITED_RE = /^-(limited|partial)-$/i;
const NA_RE = /^-(na|none)-$/i;
const NA2_RE = /^-na2-$/i;
const SIMPLE_TAG_RE = /()|()|(-note-)|(-warning-)/gi;
const renderSuccessIcon = () => ;
const renderFailureIcon = () => ;
const renderPartialSuccessIcon = () => ;
const renderPendingIcon = () => ;
const renderRunningIcon = () => ;
const renderSkippedIcon = () => ;
const STATUS_ICON_DEFS = [{
re: /^-status-success-$/i,
colorClass: 'yt-status-color-success',
label: 'Success',
render: renderSuccessIcon
}, {
re: /^-status-failure-$/i,
colorClass: 'yt-status-color-failure',
label: 'Failure',
render: renderFailureIcon
}, {
re: /^-status-partial-success-$/i,
colorClass: 'yt-status-color-partial',
label: 'Partial success',
render: renderPartialSuccessIcon
}, {
re: /^-status-pending-$/i,
colorClass: 'yt-status-color-neutral',
label: 'Pending',
render: renderPendingIcon
}, {
re: /^-status-running-$/i,
colorClass: 'yt-status-color-neutral',
label: 'Running',
render: renderRunningIcon
}, {
re: /^-status-skipped-$/i,
colorClass: 'yt-status-color-neutral',
label: 'Skipped',
render: renderSkippedIcon
}];
const renderStatusBadge = def =>
{def.render()}
;
const tryParseKV = trimmed => {
const m = KV_RE.exec(trimmed);
return m ? {
key: m[1],
value: m[2].trim()
} : null;
};
const registerKey = (key, seenKeys, orderedKeys) => {
if (!seenKeys.has(key)) {
orderedKeys.push(key);
seenKeys.add(key);
}
};
const flushEntry = (currentEntry, entries) => {
if (Object.keys(currentEntry).length > 0) entries.push(currentEntry);
};
const parseDashPrefixed = (lines, entries, orderedKeys, seenKeys) => {
let currentEntry = {};
let inEntry = false;
for (const line of lines) {
const trimmed = line.trim();
if (trimmed.startsWith('- ')) {
if (inEntry) entries.push(currentEntry);
currentEntry = {};
inEntry = true;
const kv = tryParseKV(trimmed.substring(2).trim());
if (kv) {
registerKey(kv.key, seenKeys, orderedKeys);
currentEntry[kv.key] = kv.value;
}
} else if (inEntry && trimmed !== '') {
const kv = tryParseKV(trimmed);
if (kv) {
registerKey(kv.key, seenKeys, orderedKeys);
currentEntry[kv.key] = kv.value;
}
}
}
flushEntry(currentEntry, entries);
};
const parseBlankSeparated = (lines, entries, orderedKeys, seenKeys) => {
let currentEntry = {};
let inEntry = false;
for (const line of lines) {
const trimmed = line.trim();
if (trimmed === '') {
if (inEntry) {
flushEntry(currentEntry, entries);
currentEntry = {};
inEntry = false;
}
continue;
}
const kv = tryParseKV(trimmed);
if (!kv) continue;
const isNewEntry = !line.startsWith(' ') && !line.startsWith('\t');
if (isNewEntry && inEntry && Object.keys(currentEntry).length > 0) {
entries.push(currentEntry);
currentEntry = {};
}
registerKey(kv.key, seenKeys, orderedKeys);
currentEntry[kv.key] = kv.value;
inEntry = true;
}
flushEntry(currentEntry, entries);
};
const normalizeEntries = (entries, orderedKeys) => entries.map(entry => {
const filled = {};
for (const key of orderedKeys) filled[key] = entry[key] || '';
return filled;
});
const parseYamlTableContent = contentStr => {
if (!contentStr) return [];
const entries = [];
const orderedKeys = [];
const seenKeys = new Set();
const lines = contentStr.split('\n');
if (lines.some(line => line.trim().startsWith('- '))) {
parseDashPrefixed(lines, entries, orderedKeys, seenKeys);
} else {
parseBlankSeparated(lines, entries, orderedKeys, seenKeys);
}
return normalizeEntries(entries, orderedKeys);
};
const processText = text => {
if (!text) return text;
const parts = [];
let keyIndex = 0;
let lastIndex = 0;
let match;
while ((match = INLINE_MD_RE.exec(text)) !== null) {
if (match.index > lastIndex) parts.push(text.slice(lastIndex, match.index));
if (match[1]) {
parts.push({match[2]});
} else if (match[4]) {
parts.push({match[5]});
} else if (match[6]) {
parts.push({match[7]});
} else if (match[8]) {
parts.push({match[9]});
}
lastIndex = match.index + match[0].length;
}
if (lastIndex < text.length) parts.push(text.slice(lastIndex));
if (parts.length === 0) return text;
const keyRef = {
current: keyIndex
};
return expandHtmlTags(parts, keyRef);
};
const processBadges = text => {
if (!text || typeof text !== 'string') return text;
if (YES_RE.test(text)) return ✓;
if (NO_RE.test(text)) return ✗;
if (LIMITED_RE.test(text)) return ◐;
if (NA_RE.test(text) || NA2_RE.test(text)) return Not applicable;
const statusBadge = STATUS_ICON_DEFS.find(def => def.re.test(text));
if (statusBadge) return renderStatusBadge(statusBadge);
return processText(text);
};
const cellClassName = text => {
if (!text || typeof text !== 'string') return undefined;
if (NA_RE.test(text)) return 'yt-cell-na';
if (NA2_RE.test(text)) return 'yt-cell-na2';
return undefined;
};
const expandSimpleTags = (str, keyRef) => {
const result = [];
let last = 0;
SIMPLE_TAG_RE.lastIndex = 0;
let m;
while ((m = SIMPLE_TAG_RE.exec(str)) !== null) {
if (m.index > last) result.push(str.slice(last, m.index));
if (m[1]) {
result.push( );
} else if (m[2]) {
result.push( , );
} else if (m[3]) {
result.push(Note: );
} else if (m[4]) {
result.push(Warning: );
}
last = m.index + m[0].length;
}
if (last < str.length) result.push(str.slice(last));
return result;
};
const expandHtmlTags = (chunks, keyRef) => {
const out = [];
for (const chunk of chunks) {
if (typeof chunk === 'string') {
out.push(...expandSimpleTags(chunk, keyRef));
} else {
out.push(chunk);
}
}
return out;
};
const extractText = node => {
if (node === null || node === undefined) return '';
if (typeof node === 'string') return node;
if (typeof node === 'number') return String(node);
if (typeof node === 'boolean') return '';
if (Array.isArray(node)) return node.map(extractText).join('');
if (node && typeof node === 'object' && node.type) {
const props = node.props || ({});
if (typeof props.children === 'string') return props.children;
if (props.children) return extractText(props.children);
return '';
}
return String(node || '');
};
const [mounted, setMounted] = useState(false);
const scrollWrapRef = useRef(null);
const [isScrollable, setIsScrollable] = useState(false);
useEffect(() => {
setMounted(true);
}, []);
const data = useMemo(() => {
if (propData) return propData;
if (content && typeof content === 'string') return parseYamlTableContent(content);
if (!children) return [];
if (typeof children === 'string') return parseYamlTableContent(children);
const childrenArray = Array.isArray(children) ? children : [children];
return parseYamlTableContent(childrenArray.map(extractText).join('').trim());
}, [children, propData, content]);
const columns = useMemo(() => {
if (!data || data.length === 0) return [];
const firstRow = data[0];
if (!firstRow || typeof firstRow !== 'object') return [];
return Object.keys(firstRow);
}, [data]);
useEffect(() => {
const wrap = scrollWrapRef.current;
if (!wrap) return undefined;
const updateScrollable = () => {
setIsScrollable(wrap.scrollWidth > wrap.clientWidth);
};
updateScrollable();
const observer = new ResizeObserver(updateScrollable);
observer.observe(wrap);
return () => observer.disconnect();
}, [mounted, data]);
if (!mounted) return null;
if (!data || data.length === 0) return null;
const rowKey = row => columns.map(c => row[c] || '').join('|');
return
{columns.map(col =>
{col.replaceAll('_', ' ')}
)}
{data.map(row =>
{columns.map(col =>
{processBadges(row[col])}
)}
)}
;
};
Package Firewall authenticates every request with one API key, so each event in the logs names that key rather than a person. User attribution adds a label to the credentials on each request, and Package Firewall records that label as the user on the event.
Attribution is informational. Your API key ID and secret still control access. The label does not grant or restrict any permission, and rotating the key does not change how attribution works.
You can view the attributed user on each event and query the logs by attributed user. See [View Package Firewall logs](/package-firewall/logs) to learn more.
## How the label reaches Package Firewall
A client carries the label in the Basic-auth username, using the following format. The password stays your API secret.
```text theme={null}
base64(base64("userattr:" +