{selected
?
+ emit={emit} state={state} peerName={peerName}
+ showPurlBuilder={showPurlBuilder}
+ onTogglePurlBuilder={() => setShowPurlBuilder(value => !value)} />
:
Select a software entry, or click + to add one.
}
@@ -1971,7 +2411,360 @@
);
}
-function SoftwareDetail({ sw, base, emit, state, peerName }) {
+function RequirementBadge({ requirement='optional' }) {
+ return
{requirement} ;
+}
+
+function PurlComponentGuidance({ definition, component }) {
+ const def = componentDefinition(definition, component);
+ if (!def || !Object.keys(def).length) return null;
+ const notes = [];
+ if (def.native_name) notes.push(`Native name: ${def.native_name}`);
+ if (def.case_sensitive === false) notes.push('Canonical value will be lowercased.');
+ if (def.permitted_characters) notes.push(`Pattern: ${def.permitted_characters}`);
+ if (def.note) notes.push(def.note);
+ return notes.length ?
{notes.join(' · ')}
: null;
+}
+
+function PurlBuilderPanel({ sourceSw, emit }) {
+ const [typeDefinitions, setTypeDefinitions] = useState(() => ({
+ ...deepClone(BUILTIN_PURL_TYPE_DEFINITIONS),
+ ...loadStoredPurlDefinitions(),
+ }));
+ const [pType, setPType] = useState('generic');
+ const [pNamespace, setPNamespace] = useState('');
+ const [pName, setPName] = useState('');
+ const [pVersion, setPVersion] = useState('');
+ const [pSubpath, setPSubpath] = useState('');
+ const [qualifierValues, setQualifierValues] = useState({});
+ const [extraQualifiers, setExtraQualifiers] = useState([]);
+ const [relationship, setRelationship] = useState('Uses');
+ const [built, setBuilt] = useState('');
+ const [parseInput, setParseInput] = useState('');
+ const [definitionMessages, setDefinitionMessages] = useState([]);
+
+ const normalizedType = pType.trim().toLowerCase();
+ const selectedDefinition = typeDefinitions[normalizedType] || null;
+ const qualifierDefinitions = selectedDefinition?.qualifiers_definition || [];
+ const typeOptions = useMemo(() => Object.values(typeDefinitions).sort((a,b) => a.type.localeCompare(b.type)), [typeDefinitions]);
+
+ useEffect(() => {
+ setBuilt('');
+ }, [sourceSw?.UUID]);
+
+ useEffect(() => {
+ setQualifierValues(prev => {
+ const next = {};
+ for (const q of qualifierDefinitions) next[q.key] = prev[q.key] ?? '';
+ return next;
+ });
+ if (componentRequirement(selectedDefinition, 'namespace', 'optional') === 'prohibited') setPNamespace('');
+ }, [normalizedType, selectedDefinition]);
+
+ function collectQualifiers() {
+ const out = {};
+ for (const qDef of qualifierDefinitions) {
+ const raw = String(qualifierValues[qDef.key] ?? '').trim();
+ const value = raw || (qDef.default_value !== undefined ? String(qDef.default_value) : '');
+ if (value) out[qDef.key.toLowerCase()] = value;
+ }
+ for (const row of extraQualifiers) {
+ const key = String(row.key || '').trim().toLowerCase();
+ const value = String(row.value || '').trim();
+ if (!key && !value) continue;
+ if (!PURL_QUALIFIER_KEY_PATTERN.test(key)) throw new Error(`Invalid qualifier key: ${key || '(blank)'}`);
+ if (!value) throw new Error(`Qualifier ${key} requires a value.`);
+ if (Object.prototype.hasOwnProperty.call(out, key)) throw new Error(`Duplicate qualifier key: ${key}`);
+ out[key] = value;
+ }
+ return out;
+ }
+
+ const validation = useMemo(() => {
+ try {
+ return validatePurlFields({
+ type: pType,
+ namespace: pNamespace,
+ name: pName,
+ version: pVersion,
+ qualifiers: collectQualifiers(),
+ subpath: pSubpath,
+ }, selectedDefinition);
+ } catch (err) {
+ return { fields:null, errors:[err.message], warnings:[] };
+ }
+ }, [pType, pNamespace, pName, pVersion, pSubpath, qualifierValues, extraQualifiers, selectedDefinition]);
+
+ const livePreview = useMemo(() => {
+ if (!validation.fields || validation.errors.length) return '';
+ try { return buildPackageUrl(validation.fields); } catch { return ''; }
+ }, [validation]);
+
+ function build() {
+ const qualifiers = collectQualifiers();
+ const checked = validatePurlFields({
+ type: pType,
+ namespace: pNamespace,
+ name: pName,
+ version: pVersion,
+ qualifiers,
+ subpath: pSubpath,
+ }, selectedDefinition);
+ if (checked.errors.length) throw new Error(checked.errors.join('\n'));
+ const purl = buildPackageUrl(checked.fields);
+ setBuilt(purl);
+ return { purl, fields:checked.fields, warnings:checked.warnings };
+ }
+
+ function applyParsedPurl(value) {
+ const parsed = parsePackageUrl(value);
+ setPType(parsed.type);
+ setPNamespace(parsed.namespace);
+ setPName(parsed.name);
+ setPVersion(parsed.version);
+ setPSubpath(parsed.subpath);
+ const def = typeDefinitions[parsed.type];
+ const known = new Set((def?.qualifiers_definition || []).map(q => q.key.toLowerCase()));
+ const definedValues = {}, extras = [];
+ for (const [key, val] of Object.entries(parsed.qualifiers)) {
+ if (known.has(key)) definedValues[key] = val;
+ else extras.push({ id:genUUID(), key, value:val });
+ }
+ setQualifierValues(definedValues);
+ setExtraQualifiers(extras);
+ setParseInput(value);
+ setBuilt(value);
+ }
+
+ async function importTypeDefinitionFiles(files) {
+ const messages = [], next = { ...typeDefinitions };
+ for (const file of Array.from(files || [])) {
+ try {
+ const parsed = JSON.parse(await file.text());
+ const candidates = Array.isArray(parsed) ? parsed : Array.isArray(parsed.types) ? parsed.types : [parsed];
+ for (const candidate of candidates) {
+ const errors = validatePurlTypeDefinition(candidate);
+ if (errors.length) {
+ messages.push({ level:'error', text:`${file.name}: ${errors.join(' ')}` });
+ continue;
+ }
+ const normalized = normalizePurlTypeDefinition(candidate);
+ next[normalized.type] = normalized;
+ messages.push({ level:'success', text:`Loaded ${normalized.type_name} (${normalized.type}).` });
+ }
+ } catch (err) {
+ messages.push({ level:'error', text:`${file.name}: ${err.message}` });
+ }
+ }
+ setTypeDefinitions(next);
+ persistPurlDefinitions(next);
+ setDefinitionMessages(messages);
+ }
+
+ function removeImportedDefinition(type) {
+ const next = { ...typeDefinitions };
+ if (BUILTIN_PURL_TYPE_DEFINITIONS[type]) next[type] = deepClone(BUILTIN_PURL_TYPE_DEFINITIONS[type]);
+ else delete next[type];
+ setTypeDefinitions(next);
+ persistPurlDefinitions(next);
+ if (normalizedType === type && !next[type]) setPType('generic');
+ }
+
+ function applyQualifierDefaults() {
+ const next = { ...qualifierValues };
+ for (const q of qualifierDefinitions) if (!String(next[q.key] || '').trim() && q.default_value !== undefined) next[q.key] = String(q.default_value);
+ setQualifierValues(next);
+ }
+
+ async function createRelatedComponent() {
+ try {
+ const { purl, fields, warnings } = build();
+ const displayName = packageNameDisplay(fields.namespace, fields.name);
+ const sw = {
+ UUID: genUUID(),
+ softwareType: ['software package'],
+ name: [
+ { nameValue: displayName, nameType: 'product name' },
+ { nameValue: purl, nameType: 'package URL (purl)' },
+ ],
+ version: fields.version || null,
+ description: `PURL software component generated for ${softwareLabel(sourceSw)}.`,
+ notHashable: true,
+ relationshipAssertion: 'Root',
+ metadata: [{
+ generatedBy: 'SBOM Workbench PURL builder',
+ generatedAt: isoNow(),
+ purlTypeDefinition: selectedDefinition?.$id || null,
+ purlValidationWarnings: warnings.length ? warnings : undefined,
+ }],
+ supplementaryFiles: null,
+ };
+ await emit({
+ type: OP.SW_ADD_PURL_REL,
+ xUUID: sourceSw.UUID,
+ software: sw,
+ relationship,
+ });
+ setBuilt(purl);
+ } catch (err) {
+ alert('Could not create PURL component: ' + err.message);
+ }
+ }
+
+ if (!sourceSw) return null;
+ const namespaceRequirement = componentRequirement(selectedDefinition, 'namespace', 'optional');
+ const nameRequirement = componentRequirement(selectedDefinition, 'name', 'required');
+ const versionRequirement = componentRequirement(selectedDefinition, 'version', 'optional');
+ const subpathRequirement = componentRequirement(selectedDefinition, 'subpath', 'optional');
+
+ return (
+
+
+
Create related PURL component
+
xUUID source
+
{sourceSw.UUID}
+
type-definition schema 1.0
+
+
+ Builds and validates a Package URL, creates a new CyTRICS software entry with notHashable: true ,
+ stores the PURL in name[] , and creates a relationship from the selected file to the new component.
+ Imported type definitions are checked against the supplied Package-URL type-definition schema structure and saved in this browser.
+
+
+
+ Type-definition registry and PURL parser
+
+
+
Load concrete type-definition JSON
+
importTypeDefinitionFiles(e.target.files)} />
+
+ A type-definition schema describes the definition format; load concrete package-type definitions here. Load one or more concrete definition files to replace the built-in starter templates.
+
+ {definitionMessages.map((m,i) =>
{m.text}
)}
+
+
+
Parse an existing PURL into the builder
+
+ { try { applyParsedPurl(parseInput); } catch (err) { alert(err.message); } }}>Parse
+
+
+
+
+
+
+
+
+
+
Qualifiers
+
Defined qualifiers are rendered from the selected type definition. Additional qualifiers are allowed but flagged when not declared by that definition.
+
+
+ {qualifierDefinitions.some(q=>q.default_value !== undefined) && Apply defaults }
+ setExtraQualifiers([...extraQualifiers, {id:genUUID(), key:'', value:''}])}> Additional qualifier
+
+
+ {qualifierDefinitions.length === 0 && extraQualifiers.length === 0 &&
No type-specific qualifiers are declared.
}
+ {qualifierDefinitions.map(q => (
+
+
+
{q.key} {q.native_name && {q.native_name} }
+
{q.description}{q.default_value !== undefined ? ` Default: ${q.default_value}` : ''}
+
+
setQualifierValues({...qualifierValues, [q.key]:e.target.value})} placeholder={q.default_value !== undefined ? `default: ${q.default_value}` : 'qualifier value'} />
+
+ ))}
+ {extraQualifiers.map((row, idx) => (
+
+ setExtraQualifiers(extraQualifiers.filter(x=>x.id!==row.id))}>
+
+ ))}
+
+
+
+
Subpath } hint={componentDefinition(selectedDefinition, 'subpath').native_name || ''}>
+
+
+ {selectedDefinition ? <>
+
+ {selectedDefinition.type_name}
+ {selectedDefinition.type}
+ {BUILTIN_PURL_TYPE_DEFINITIONS[selectedDefinition.type] && deepEqual(selectedDefinition, BUILTIN_PURL_TYPE_DEFINITIONS[selectedDefinition.type])
+ ? starter template
+ : imported definition }
+
+
{selectedDefinition.description}
+ {selectedDefinition.repository?.use_repository &&
Repository: {selectedDefinition.repository.default_repository_url || 'type uses a public repository'}
}
+ {selectedDefinition.note &&
{selectedDefinition.note}
}
+ {(selectedDefinition.namespace_definition?.normalization_rules || selectedDefinition.name_definition?.normalization_rules || selectedDefinition.version_definition?.normalization_rules || selectedDefinition.subpath_definition?.normalization_rules) &&
+
Normalization rules
+
+ {['namespace','name','version','subpath'].flatMap(component => (componentDefinition(selectedDefinition, component).normalization_rules || []).map((rule,i)=>{component}: {rule}
+ }
+ {selectedDefinition.examples?.length > 0 &&
+
Examples — click to load
+ {selectedDefinition.examples.slice(0,5).map(ex =>
{ try { applyParsedPurl(ex); } catch(err) { alert(err.message); } }}>{ex} )}
+
}
+ {!BUILTIN_PURL_TYPE_DEFINITIONS[selectedDefinition.type] || !deepEqual(selectedDefinition, BUILTIN_PURL_TYPE_DEFINITIONS[selectedDefinition.type]) ?
+
removeImportedDefinition(selectedDefinition.type)}>Remove imported definition : null}
+ : <>
+
No matching type definition loaded
+
The builder will validate base PURL syntax only. Import a concrete type-definition JSON file for component and qualifier rules.
+ }
+
+
+
+ {validation.errors.length > 0 &&
Validation errors {validation.errors.map((x,i)=>{x} )} }
+ {validation.warnings.length > 0 &&
Warnings {validation.warnings.map((x,i)=>{x} )} }
+ {!validation.errors.length && !validation.warnings.length && pName.trim() &&
PURL components satisfy the currently loaded type definition.
}
+
+
+
Canonical PURL preview
+
{livePreview || built || Complete the required fields to generate a preview. }
+
+
+ { try { build(); } catch (e) { alert(e.message); } }}>
+ Validate + build PURL
+
+ 0 || !pName.trim()}>
+ Create software entry + relationship
+
+
+
+ );
+}
+
+function SoftwareDetail({ sw, base, emit, state, peerName, showPurlBuilder=false, onTogglePurlBuilder }) {
// Quick edits emit a setField op against the entry's current anchor.
const [anchor, setAnchor] = useState(null);
useEffect(() => {
@@ -2001,13 +2794,27 @@
{sw.UUID}
{!base &&
added }
-
+
+
+
+ {showPurlBuilder ? 'Hide PURL Builder' : 'Build Related PURL'}
+
Remove
+ {showPurlBuilder && (
+
+ )}
+